api design

Current tool-augmented large language model (LLM) ecosystems suffer from fragmentation—characterized by coexisting heterogeneous protocols (e.g., OpenAI Function Calling, Toolformer), manual schema definition, and complex execution orchestration—leading to low development efficiency and high integration overhead. To address this, we propose a protocol-agnostic unified tool integration framework. Our approach introduces an abstract protocol layer for cross-standard compatibility, an automated schema inference mechanism to eliminate manual specification, and a dual-mode concurrent scheduler enabling seamless synchronous and asynchronous tool execution. Experimental evaluation demonstrates that, compared to baseline approaches, our framework reduces implementation code volume by 60–80%, achieves up to 3.1× improvement in end-to-end execution latency, and maintains full backward compatibility with mainstream LLM tool-calling ecosystems.

This paper addresses the disconnect between monadic abstractions and explicit stack manipulation in higher-order functional languages. We propose a stack-aware effect modeling methodology based on the call-by-push-value (CBPV) calculus. Our key contributions are threefold: (1) the first formalization of stack-manipulation effects using relative monads; (2) the design of “monadic blocks”—syntactic sugar generalizing Haskell’s do-notation to support customizable stack layouts; and (3) an automated lifting mechanism from relative monads to relative monad transformers, circumventing the theoretical impossibility of constructing monad transformers in purely functional settings. The resulting type system supports effect implementations over arbitrary stack layouts, enables faithful migration of standard monads, and provides a compositional, reasoning-friendly effect abstraction framework for compiler backends and assembly-level code generation. (138 words)

This work proposes a novel reflective protocol that enables runtime upward navigation through the semantic tower—a capability absent in existing runtime systems, which are restricted to downward execution along abstraction layers. By formally integrating operational semantics with runtime reflection, the approach introduces the notion of “first-class implementations” and establishes a generalized safe-point mechanism grounded in formal specifications. This mechanism permits observation and dynamic switching of high-level abstractions’ underlying implementations during execution, thereby overcoming the traditional limitation of supporting only downward compilation or interpretation. The study demonstrates, for the first time, the feasibility and effectiveness of deeply integrating semantic theory with runtime system design, enabling adaptive and semantically aware execution environments.

This work addresses two key challenges in compiler education: low reusability of intermediate language (IL) testing frameworks and the difficulty of reconciling high-level safety abstractions with low-level assembly features. We propose a family-of-intermediate-languages design methodology based on Racket macro embedding. Leveraging local macro expansion, we uniformly embed a series of ILs—from Scheme-like source languages to x86-64 target code—into Racket, enabling semantic-level interoperability between higher-order functional abstractions and unsafe assembly primitives. Our approach innovates by supporting open, modular composition of language features: ILs can be dynamically assembled without modifying the host language. The resulting interpreter exposes multiple interfaces, significantly simplifying semantic specification and test development. Evaluated in university compiler courses, our framework has improved IL reuse and pedagogical scalability.

Existing LLM orchestration scripts suffer from insufficient modularity and limited parallelization capabilities. To address these issues, this paper proposes an abstract framework grounded in algebraic effects and composable effect handlers, which decouples side effects—such as LLM invocations, I/O operations, and concurrency—into replaceable, composable effect interfaces. This design enforces a strict separation between workflow logic and execution details, preserving code clarity and maintainability while natively enabling fine-grained parallel scheduling and optimization. Evaluated on Tree-of-Thoughts reasoning tasks, the framework achieves a 10× end-to-end performance improvement over baseline approaches. Results demonstrate that the method effectively enhances execution efficiency without compromising modularity, confirming its validity and broad applicability across LLM-driven workflows.

Modular control-flow handling in abstract interpretation and supporting multiple analysis strategies—such as path- vs. flow-sensitivity, forward vs. backward directionality, and upper vs. lower approximations—traditionally relies on complex monad transformers, leading to implementation brittleness and poor composability. Method: This paper introduces the *cumulative abstract semantics* framework, the first to incorporate *scoped effects* into abstract interpretation. It decouples syntactic structure from semantic behavior via two classes of effect handlers: *syntax-resolving* and *domain-semantics-introducing*. A single syntax-driven interpreter suffices to generate diverse dynamic evaluators and static analyzers. Contribution/Results: The framework eliminates heavyweight data structures, preserving expressiveness while drastically reducing implementation complexity for multi-strategy analyses. It enhances maintainability, composability, and modularity—providing a concise, unified, and extensible theoretical and practical foundation for modular program analysis.

This study addresses the imbalance in the test pyramid—characterized by an overreliance on coarse-grained integration and system tests, which leads to difficulties in fault localization and slow execution—by proposing, for the first time, a method to automatically generate unit tests from existing integration tests. The approach combines static and dynamic analysis to automatically isolate component dependencies and enhance coverage at the unit level. Implemented as a Node.js tool and evaluated on twelve open-source JavaScript projects, the technique produces high-quality unit tests that significantly improve test suite structure, thereby increasing both testing efficiency and maintainability.

This work proposes a Pythonic adaptation of the PIMPL (Pointer-to-Implementation) design pattern to address the challenge of maintaining stable APIs in large, evolving Python libraries, where users often inadvertently depend on internal implementation details. By introducing lightweight public objects that delegate calls opaquely to hidden implementations, the approach effectively isolates internal complexity. The design systematically integrates module-level indirection, facade objects, backend dispatching, and lazy imports to construct a decoupled encapsulation architecture. Empirical evaluation demonstrates that this paradigm enables runtime backend switching and lazy loading, significantly enhancing API stability and long-term maintainability in both the Python standard library and scientific computing ecosystems. The resulting pattern offers a general, reusable solution for robust library design in Python.

This work addresses the challenge that existing programming environments, relying solely on plain-text editing, struggle to reliably track and maintain program structure during tool integration. To bridge this gap, the paper proposes a hybrid structured editing approach that preserves the familiar text-based interface for users while providing structural guarantees for tools. By integrating declarative structural constraints, a mechanism for tracking structural changes, and a synchronization strategy between textual and structural representations, the method ensures consistency and safety of program structure throughout the editing process. This approach is the first to simultaneously accommodate user editing habits and the structural reliability required by development tools. A prototype implementation and multiple case studies demonstrate its effectiveness in enhancing both the safety of tool integration and the consistency of the user experience.

Existing LLM prompting research focuses narrowly on function-level tasks, overlooking project-level complexities—such as multi-class dependencies—and human–LLM interaction (HLI) characteristics critical to real-world software development. Method: We conduct an empirical study of developers interacting with ChatGPT for both function-level and project-level code generation. Using a novel project-level benchmark incorporating diverse inter-class dependencies, we collect fine-grained behavioral data via synchronized screen recordings and chat logs in controlled comparative experiments. Contribution/Results: We identify three HLI features significantly impacting generation efficiency; establish a fine-grained taxonomy of 29 error types; and derive five actionable, empirically grounded prompting guidelines. These findings provide both theoretical insight and practical guidance for enhancing LLM productivity in authentic software engineering contexts.