function calling

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.

Current large language model (LLM) applications face significant bottlenecks in tool integration—including fragmentation, tight protocol coupling, and implementation complexity. To address these challenges, this paper proposes a protocol-agnostic unified tool management architecture. The architecture abstracts tool registration, representation, execution, and lifecycle management, ensuring full (100%) compatibility with the OpenAI function-calling standard. It integrates a unified interface design, concurrent execution mechanisms, and modular encapsulation techniques to enable multi-protocol adaptation and dynamic tool discovery. Experimental results demonstrate a 60–80% reduction in tool integration code and up to a 3.1× improvement in end-to-end execution performance. The architecture has been validated in real-world production environments, confirming its efficiency, maintainability, and scalability.

This paper addresses the narrow design-space exploration and severe information overload in LLM-assisted programming by proposing an IDE framework deeply integrated into the design process. Methodologically, it elevates LLMs from single-point code generators to collaborative design-space exploration agents—a novel conceptual shift—explicitly modeling problem variants, solution pathways, and implicit assumptions via a design decision graph, and enabling multi-perspective problem reformulation and parallel solution generation. Contributions include: (1) establishing the first LLM-IDE co-design paradigm specifically for program design-space exploration; (2) enabling design decisions to be traceable, comparable, and evolvable; and (3) demonstrating through user studies a statistically significant increase in design breadth. The work further identifies attention management as the core bottleneck in LLM-augmented IDEs, thereby providing a new benchmark for human-AI collaborative design research.

To address the scarcity of high-quality, diverse function-calling training data and the limited coverage and low accuracy of existing synthetic approaches, this paper proposes a self-evolving multi-agent data synthesis framework. First, it introduces an API self-evolution mining mechanism to construct a highly comprehensive toolset covering 26,507 APIs. Second, it integrates multi-agent collaborative dialogue with formal reasoning guidance to generate instruction-call pairs exhibiting high complexity and diversity. Third, it employs a dual-layer verification scheme—combining rule-based checks and large language model (LLM) evaluation—to ensure both semantic correctness and executable accuracy. Remarkably, using only an 8B-parameter model, our method achieves state-of-the-art performance on the Berkeley Function-Calling Benchmark, matching GPT-4’s accuracy. The code, model weights, and a subset of synthesized data are publicly released on Hugging Face.

This work addresses the challenge that large language models often generate inaccurate function parameters when invoking functions with complex interdependent arguments, due to the absence of explicit reasoning mechanisms. To overcome this limitation, the authors propose a novel function-calling framework that embeds explicit reasoning at both the function and parameter levels. The approach introduces a universal “think” parameter to enhance decision expressivity, dynamically refines parameter descriptions, and automatically triggers fine-grained reasoning based on a complexity-aware scoring mechanism. Notably, the method requires no modifications to the underlying model architecture and preserves full API compatibility. It is the first to enable parameter-level reasoning guidance and improves alignment with human expectations through reasoning coherence. Experiments on ToolBench demonstrate significant gains in generation accuracy and reasoning consistency for multi-parameter functions, while also enhancing the interpretability of agent behavior.

Developing native database functions is costly and error-prone, while general-purpose code generation approaches struggle to handle their intricate contextual and dependency requirements. To address this challenge, this work proposes DBCooker—the first specialized framework for synthesizing native database functions. DBCooker innovatively integrates function signature extraction, structured pseudocode planning, component-aware hybrid fill-in-the-blank generation, LLM-guided semantic validation, and a history-aware, adaptive orchestration strategy that tracks cross-unit dependencies. Evaluated on SQLite, PostgreSQL, and DuckDB, the system achieves an average accuracy improvement of 34.55% and successfully synthesizes novel functions not yet supported in SQLite v3.50.

This work identifies and formally characterizes a previously undocumented phenomenon—termed “tool-call suppression”—where multiple open-source large language models fail to invoke tools when both tool-calling capabilities and structured output constraints (e.g., JSON Schema) are simultaneously enabled, despite functioning correctly in isolation. The authors propose the “constraint priority inversion” hypothesis, arguing that structured output constraints impose syntactic masking during decoding that inadvertently blocks tokens necessary for tool invocation. To address this, they introduce a transparent, two-stage execution strategy that decouples tool calling from structured generation without requiring model retraining. Experimental results demonstrate that this approach effectively restores tool-calling functionality while preserving strict adherence to output schemas, substantially enhancing agent reliability under joint constraints.

This work addresses the inherent limitation of large language models (LLMs) whose plain-text interfaces struggle to distinguish structural and semantic roles—such as instructions versus data—within inputs, thereby increasing susceptibility to confusion and prompt injection attacks. To mitigate this, the authors propose LLMON, a native markup language for LLMs that explicitly encodes semantic roles through a custom syntax, embedding structured metadata throughout training, prompting, and inference. Analogous to type systems in programming languages, LLMON enables both static and dynamic parsing with built-in safety checks, substantially enhancing model accuracy and robustness while effectively defending against prompt injection. This approach establishes a novel paradigm and a standardized pathway for designing safer, more reliable LLM interfaces.

This work addresses a critical security vulnerability in AI agents wherein tool selection mechanisms are susceptible to manipulation, potentially leading to the forced invocation of malicious functions. To this end, the paper introduces a novel Function Hijacking Attack (FHA) that, for the first time, achieves context-agnostic and universally applicable adversarial function calls across diverse queries and payload configurations. By integrating adversarial example generation with an in-depth analysis of large language models’ tool selection behavior, the proposed method demonstrates high effectiveness and broad generalizability, achieving attack success rates of 70%–100% across five state-of-the-art models and a wide range of function sets.

This study addresses the unclear human-AI collaboration mechanisms in specification-driven software development with large language models (LLMs). We propose CURRANTE, a structured three-stage collaborative paradigm that guides developers through sequential refinement of requirements specifications, test cases, and function implementations. Implemented as a Visual Studio Code extension, CURRANTE integrates LLM assistance, fine-grained interaction logging, and automated test-based evaluation. By collecting interaction data and multidimensional performance metrics—including pass rates and completion time—on medium-difficulty tasks from LiveCodeBench, our work provides the first systematic empirical analysis of how iterative specification and testing dynamically influence LLM-generated code quality. These findings offer evidence-based insights for designing effective AI-augmented programming environments.