智能体技能

基于文件的技能

创建一个指向包含你技能的目录的AgentSkillsProvider，并将其添加到代理的上下文提供者中。 传递一个脚本执行器以允许执行技能目录中存在的基于文件的脚本：

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using OpenAI.Responses;

string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")!;
string deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";

// Discover skills from the 'skills' directory
var skillsProvider = new AgentSkillsProvider(
    Path.Combine(AppContext.BaseDirectory, "skills"));

// Create an agent with the skills provider
AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetResponsesClient()
    .AsAIAgent(new ChatClientAgentOptions
    {
        Name = "SkillsAgent",
        ChatOptions = new()
        {
            Instructions = "You are a helpful assistant.",
        },
        AIContextProviders = [skillsProvider],
    },
    model: deploymentName);

多个技能目录

可以将提供程序指向一个父目录：每个包含 SKILL.md 的子目录都会自动被识别为技能。

var skillsProvider = new AgentSkillsProvider(
    Path.Combine(AppContext.BaseDirectory, "all-skills"));

或者传递路径列表以搜索多个根目录：

var skillsProvider = new AgentSkillsProvider(
    [
        Path.Combine(AppContext.BaseDirectory, "company-skills"),
        Path.Combine(AppContext.BaseDirectory, "team-skills"),
    ]);

提供程序最多搜索两个级别。

自定义资源发现

默认情况下，提供程序在references和assets子目录中识别具有.md、.json、.yaml、.yml、.csv、.xml和.txt扩展名的资源。 用于 AgentFileSkillsSourceOptions 更改以下默认值：

var fileOptions = new AgentFileSkillsSourceOptions
{
    AllowedResourceExtensions = [".md", ".txt"],
    ResourceDirectories = ["docs", "templates"],
};

var skillsProvider = new AgentSkillsProvider(
    Path.Combine(AppContext.BaseDirectory, "skills"),
    fileOptions: fileOptions);

脚本执行

将 SubprocessScriptRunner.RunAsync 作为第二个参数传递给 AgentSkillsProvider 来启用通过文件的脚本执行：

var skillsProvider = new AgentSkillsProvider(
    Path.Combine(AppContext.BaseDirectory, "skills"),
    SubprocessScriptRunner.RunAsync);

SubprocessScriptRunner.RunAsync 大致等效于以下内容：

// Simplified equivalent of what SubprocessScriptRunner.RunAsync does internally
using System.Diagnostics;

static async Task<string> RunAsync(AgentSkill skill, AgentSkillScript script, IDictionary<string, object?>? args)
{
    var psi = new ProcessStartInfo("python3")
    {
        RedirectStandardOutput = true,
        UseShellExecute = false,
    };
    psi.ArgumentList.Add(Path.Combine(skill.Path, script.Path));
    if (args != null)
    {
        foreach (var (key, value) in args)
        {
            if (value is not null)
            {
                psi.ArgumentList.Add($"--{key}");
                psi.ArgumentList.Add(value.ToString()!);
            }
        }
    }
    using var process = Process.Start(psi)!;
    string output = await process.StandardOutput.ReadToEndAsync();
    await process.WaitForExitAsync();
    return output.Trim();
}

运行程序将每个发现的脚本作为本地子进程运行，将代理提供的 JSON 参数转发为命令行标志。

自定义脚本发现

默认情况下，提供程序会识别在scripts子目录中的具有.py、.js、.sh、.ps1、.cs和.csx扩展名的脚本。 用于 AgentFileSkillsSourceOptions 更改以下默认值：

传递给AgentFileSkillsSourceOptionsAgentSkillsProvider构造函数或传递给UseFileSkill / UseFileSkills生成器。

var fileOptions = new AgentFileSkillsSourceOptions
{
    AllowedScriptExtensions = [".py"],
    ScriptDirectories = ["scripts", "tools"],
};

// Via constructor
var skillsProvider = new AgentSkillsProvider(
    Path.Combine(AppContext.BaseDirectory, "skills"),
    fileOptions: fileOptions);

// Via builder
var skillsProvider = new AgentSkillsProviderBuilder()
    .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"), options: fileOptions)
    .Build();

基于文件的技能

创建一个指向包含您技能的目录的SkillsProvider，并将其添加到代理的上下文提供者中。

import os
from pathlib import Path
from agent_framework import SkillsProvider
from agent_framework.openai import OpenAIChatCompletionClient
from azure.identity.aio import AzureCliCredential

# Discover skills from the 'skills' directory
skills_provider = SkillsProvider(
    skill_paths=Path(__file__).parent / "skills"
)

# Create an agent with the skills provider
agent = OpenAIChatCompletionClient(
    model=os.environ["AZURE_OPENAI_CHAT_COMPLETION_MODEL"],
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    credential=AzureCliCredential(),
).as_agent(
    name="SkillsAgent",
    instructions="You are a helpful assistant.",
    context_providers=[skills_provider],
)

多个技能目录

可以将提供程序指向单个父文件夹，包含 SKILL.md 的每个子文件夹会被自动识别为技能。

skills_provider = SkillsProvider(
    skill_paths=Path(__file__).parent / "all-skills"
)

或者传递路径列表以搜索多个根目录：

skills_provider = SkillsProvider(
    skill_paths=[
        Path(__file__).parent / "company-skills",
        Path(__file__).parent / "team-skills",
    ]
)

提供程序最多搜索两个级别。

自定义资源发现

默认情况下， SkillsProvider 识别具有扩展 .md、 .json、 .yaml、 .yml、 .csv、 .xml和的资源 .txt。 它会扫描每个技能文件夹中的所有子目录。 传递 resource_extensions 以更改已识别的文件类型：

skills_provider = SkillsProvider(
    skill_paths=Path(__file__).parent / "skills",
    resource_extensions=(".md", ".txt"),
)

脚本执行

若要启用基于文件的脚本执行，请将 script_runner 传递给 SkillsProvider。 可以使用满足 SkillScriptRunner 协议的任何同步或异步可调用项：

from pathlib import Path
from agent_framework import Skill, SkillScript, SkillsProvider

def my_runner(skill: Skill, script: SkillScript, args: dict | None = None) -> str:
    """Run a file-based script as a subprocess."""
    import subprocess, sys
    cmd = [sys.executable, str(Path(skill.path) / script.path)]
    if args:
        for key, value in args.items():
            if value is not None:
                cmd.extend([f"--{key}", str(value)])
    result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
    return result.stdout.strip()

skills_provider = SkillsProvider(
    skill_paths=Path(__file__).parent / "skills",
    script_runner=my_runner,
)

运行程序接收已解析的Skill、SkillScript以及可选args字典。 基于文件的脚本会自动从 .py 技能目录中的文件发现。

除了从 SKILL.md 文件中发现的基于文件的技能之外，还可以使用 AgentInlineSkill完全在代码中定义技能。 代码定义的技能在以下情况下非常有用：

• 技能内容是动态生成的（例如，从数据库或环境读取）。
• 你希望将技能定义与使用它们的应用程序代码一起保留。
• 你需要在读取时执行逻辑的资源，而不是提供静态文件。

基本代码技能

使用名称、描述和指令创建一个 AgentInlineSkill 。 使用 .AddResource() 附加资源：

using Microsoft.Agents.AI;

var codeStyleSkill = new AgentInlineSkill(
    name: "code-style",
    description: "Coding style guidelines and conventions for the team",
    instructions: """
        Use this skill when answering questions about coding style, conventions, or best practices for the team.
        1. Read the style-guide resource for the full set of rules.
        2. Answer based on those rules, quoting the relevant guideline where helpful.
        """)
    .AddResource(
        "style-guide",
        """
        # Team Coding Style Guide
        - Use 4-space indentation (no tabs)
        - Maximum line length: 120 characters
        - Use type annotations on all public methods
        """);

var skillsProvider = new AgentSkillsProvider(codeStyleSkill);

动态资源

将工厂委托传递给 .AddResource()，以便在运行时计算内容。 每次代理读取资源时都会调用委托：

var projectInfoSkill = new AgentInlineSkill(
    name: "project-info",
    description: "Project status and configuration information",
    instructions: """
        Use this skill for questions about the current project.
        1. Read the environment resource for deployment configuration details.
        2. Read the team-roster resource for information about team members.
        """)
    .AddResource("environment", () =>
    {
        string env = Environment.GetEnvironmentVariable("APP_ENV") ?? "development";
        string region = Environment.GetEnvironmentVariable("APP_REGION") ?? "us-east-1";
        return $"Environment: {env}, Region: {region}";
    })
    .AddResource(
        "team-roster",
        "Alice Chen (Tech Lead), Bob Smith (Backend Engineer)");

脚本由代码定义

使用 .AddScript() 将委托注册为可执行脚本。 代码定义的脚本作为直接委托调用 运行进程内 。 不需要脚本执行器。 委托的已定义类型参数会自动转换为代理用来传递参数的 JSON 模式：

using System.Text.Json;

var unitConverterSkill = new AgentInlineSkill(
    name: "unit-converter",
    description: "Convert between common units using a conversion factor",
    instructions: """
        Use this skill when the user asks to convert between units.
        1. Review the conversion-table resource to find the correct factor.
        2. Use the convert script, passing the value and factor from the table.
        3. Present the result clearly with both units.
        """)
    .AddResource(
        "conversion-table",
        """
        # Conversion Tables
        Formula: **result = value × factor**
        | From       | To         | Factor   |
        |------------|------------|----------|
        | miles      | kilometers | 1.60934  |
        | kilometers | miles      | 0.621371 |
        | pounds     | kilograms  | 0.453592 |
        | kilograms  | pounds     | 2.20462  |
        """)
    .AddScript("convert", (double value, double factor) =>
    {
        double result = Math.Round(value * factor, 4);
        return JsonSerializer.Serialize(new { value, factor, result });
    });

var skillsProvider = new AgentSkillsProvider(unitConverterSkill);

除了从 SKILL.md 文件中发现的基于文件的技能之外，还可以在Python代码中完全定义技能。 代码定义的技能在以下情况下非常有用：

• 技能内容是动态生成的（例如，从数据库或环境读取）。
• 你希望将技能定义与使用它们的应用程序代码一起保留。
• 你需要在读取时执行逻辑的资源，而不是提供静态文件。

基本代码技能

使用具有名称、描述和指令内容的Skill实例。 （可选）附加 SkillResource 包含静态内容的实例：

from textwrap import dedent
from agent_framework import Skill, SkillResource, SkillsProvider

code_style_skill = Skill(
    name="code-style",
    description="Coding style guidelines and conventions for the team",
    content=dedent("""\
        Use this skill when answering questions about coding style,
        conventions, or best practices for the team.
    """),
    resources=[
        SkillResource(
            name="style-guide",
            content=dedent("""\
                # Team Coding Style Guide
                - Use 4-space indentation (no tabs)
                - Maximum line length: 120 characters
                - Use type annotations on all public functions
            """),
        ),
    ],
)

skills_provider = SkillsProvider(skills=[code_style_skill])

动态资源

使用 @skill.resource 修饰器将函数注册为资源。 每次代理读取资源时都会调用此函数，因此可以返回最新的数据。 支持同步和异步函数：

import os
from agent_framework import Skill

project_info_skill = Skill(
    name="project-info",
    description="Project status and configuration information",
    content="Use this skill for questions about the current project.",
)

@project_info_skill.resource
def environment() -> Any:
    """Get current environment configuration."""
    env = os.environ.get("APP_ENV", "development")
    region = os.environ.get("APP_REGION", "us-east-1")
    return f"Environment: {env}, Region: {region}"

@project_info_skill.resource(name="team-roster", description="Current team members")
def get_team_roster() -> Any:
    """Return the team roster."""
    return "Alice Chen (Tech Lead), Bob Smith (Backend Engineer)"

在没有参数的情况下使用修饰器时（@skill.resource），函数名称将成为资源名称，docstring 将成为说明。 使用 @skill.resource(name="...", description="...") 显式设置它们。

脚本由代码定义

使用 @skill.script 修饰器将函数注册为技能上的可执行脚本。 代码定义的脚本 在进程内 运行，不需要脚本执行程序。 支持同步和异步函数：

from agent_framework import Skill

unit_converter_skill = Skill(
    name="unit-converter",
    description="Convert between common units using a conversion factor",
    content="Use the convert script to perform unit conversions.",
)

@unit_converter_skill.script(name="convert", description="Convert a value: result = value × factor")
def convert_units(value: float, factor: float) -> str:
    """Convert a value using a multiplication factor."""
    import json
    result = round(value * factor, 4)
    return json.dumps({"value": value, "factor": factor, "result": result})

在没有参数的情况下使用修饰器时（@skill.script），函数名称将成为脚本名称，docstring 将成为说明。 函数的类型化参数会自动转换为代理用于传递参数的 JSON 架构。

组合基于文件的技能和代码定义的技能

将 skill_paths 和 skills 同时传递给单个 SkillsProvider。 首先发现基于文件的技能;如果代码定义的技能与现有基于文件的技能同名，则跳过代码定义的技能：

from pathlib import Path
from agent_framework import Skill, SkillsProvider

my_skill = Skill(
    name="my-code-skill",
    description="A code-defined skill",
    content="Instructions for the skill.",
)

skills_provider = SkillsProvider(
    skill_paths=Path(__file__).parent / "skills",
    skills=[my_skill],
)

基于课堂的技能

基于类的技能允许将所有技能组件（名称、说明、说明、资源和脚本）捆绑到单个 C# 类中。 从 AgentClassSkill<T> 派生（其中 T 是类），然后使用 [AgentSkillResource] 注解属性，并使用 [AgentSkillScript] 注解方法，以实现自动发现：

using System.ComponentModel;
using System.Text.Json;
using Microsoft.Agents.AI;

internal sealed class UnitConverterSkill : AgentClassSkill<UnitConverterSkill>
{
    public override AgentSkillFrontmatter Frontmatter { get; } = new(
        "unit-converter",
        "Convert between common units using a multiplication factor. Use when asked to convert miles, kilometers, pounds, or kilograms.");

    protected override string Instructions => """
        Use this skill when the user asks to convert between units.

        1. Review the conversion-table resource to find the correct factor.
        2. Use the convert script, passing the value and factor from the table.
        3. Present the result clearly with both units.
        """;

    [AgentSkillResource("conversion-table")]
    [Description("Lookup table of multiplication factors for common unit conversions.")]
    public string ConversionTable => """
        # Conversion Tables
        Formula: **result = value × factor**
        | From       | To         | Factor   |
        |------------|------------|----------|
        | miles      | kilometers | 1.60934  |
        | kilometers | miles      | 0.621371 |
        | pounds     | kilograms  | 0.453592 |
        | kilograms  | pounds     | 2.20462  |
        """;

    [AgentSkillScript("convert")]
    [Description("Multiplies a value by a conversion factor and returns the result as JSON.")]
    private static string ConvertUnits(double value, double factor)
    {
        double result = Math.Round(value * factor, 4);
        return JsonSerializer.Serialize(new { value, factor, result });
    }
}

使用AgentSkillsProvider注册基于类的技能

var skill = new UnitConverterSkill();
var skillsProvider = new AgentSkillsProvider(skill);

当 [AgentSkillResource] 属性应用于属性或方法时，其返回值将在代理读取资源时用作资源内容——如果需要在读取时计算内容，则使用方法。 当[AgentSkillScript]应用于方法时，代理调用脚本时该方法将被调用。 使用[Description]从System.ComponentModel描述代理的每一项资源和脚本。

生成器：高级多源场景

对于简单的单源方案，请直接使用 AgentSkillsProvider 构造函数。 如果需要以下任一项，请使用 AgentSkillsProviderBuilder ：

• 混合技能类型 - 在单个提供程序中合并基于文件的、代码定义的（AgentInlineSkill）和基于类的技能AgentClassSkill。
• 技能筛选 - 使用谓词包括或排除技能。

混合技能类型

将所有三种技能类型在一个提供程序中通过链式链接连接：UseFileSkill、UseSkill 和 UseFileScriptRunner。

var skillsProvider = new AgentSkillsProviderBuilder()
    .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))  // file-based skills
    .UseSkill(volumeConverterSkill)                                  // AgentInlineSkill
    .UseSkill(temperatureConverter)                                  // AgentClassSkill
    .UseFileScriptRunner(SubprocessScriptRunner.RunAsync)            // runner for file scripts
    .Build();

技能筛选

使用 UseFilter 仅包括符合您条件的技能，例如，从共享目录载入技能，但排除实验技能。

var approvedSkillNames = new HashSet<string> { "expense-report", "code-style" };

var skillsProvider = new AgentSkillsProviderBuilder()
    .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
    .UseFilter(skill => approvedSkillNames.Contains(skill.Frontmatter.Name))
    .Build();

使用 AgentSkillsProviderOptions.ScriptApproval 将所有脚本执行置于人工审批之后。 启用后，代理将暂停并返回审批请求，而不是立即执行：

var skillsProvider = new AgentSkillsProvider(
    skillPath: Path.Combine(AppContext.BaseDirectory, "skills"),
    options: new AgentSkillsProviderOptions
    {
        ScriptApproval = true,
    });

若要在生成器配置的提供程序上启用脚本审批，请使用 UseScriptApproval：

var skillsProvider = new AgentSkillsProviderBuilder()
    .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
    .UseScriptApproval(true)
    .Build();

使用require_script_approval=True在SkillsProvider上为所有脚本执行设置需要人工审批的权限。 代理会暂停并返回审批请求，而不是立即执行。

from agent_framework import Agent, Skill, SkillsProvider

# Create provider with approval enabled
skills_provider = SkillsProvider(
    skills=[my_skill],
    require_script_approval=True,
)

# Run the agent — script calls pause for approval
result = await agent.run("Deploy version 2.5.0 to production", session=session)

# Handle approval requests
while result.user_input_requests:
    for request in result.user_input_requests:
        print(f"Script: {request.function_call.name}")
        print(f"Args: {request.function_call.arguments}")

        approval = request.to_function_approval_response(approved=True)
        result = await agent.run(approval, session=session)

当脚本被拒绝（approved=False）时，代理会通知用户拒绝并可以相应地做出响应。

var skillsProvider = new AgentSkillsProvider(
    skillPath: Path.Combine(AppContext.BaseDirectory, "skills"),
    options: new AgentSkillsProviderOptions
    {
        SkillsInstructionPrompt = """
            You have skills available. Here they are:
            {skills}
            {resource_instructions}
            {script_instructions}
            """
    });

skills_provider = SkillsProvider(
    skill_paths=Path(__file__).parent / "skills",
    instruction_template=(
        "You have skills available. Here they are:\n{skills}\n"
        "Use the `load_skill` function to get skill instructions.\n"
        "Use the `read_skill_resource` function to read skill files."
    ),
)

缓存行为

默认情况下，技能工具和说明在首次生成后缓存。 将DisableCaching = true设置为AgentSkillsProviderOptions，以在每次调用时强制重建。

var skillsProvider = new AgentSkillsProvider(
    Path.Combine(AppContext.BaseDirectory, "skills"),
    options: new AgentSkillsProviderOptions
    {
        DisableCaching = true,
    });

技能资源和脚本委托函数可以声明一个 IServiceProvider 参数，代理框架会自动注入。 这样，技能就可以解析应用程序服务（例如数据库客户端、配置或业务逻辑），而无需将它们硬编码到技能定义中。

Setup

注册应用程序服务，并通过services参数将构建的IServiceProvider传递给代理：

using Microsoft.Extensions.DependencyInjection;

// Register application services
ServiceCollection services = new();
services.AddSingleton<ConversionService>();
IServiceProvider serviceProvider = services.BuildServiceProvider();

// Create the agent and pass the service provider
AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetResponsesClient()
    .AsAIAgent(
        options: new ChatClientAgentOptions
        {
            Name = "ConverterAgent",
            ChatOptions = new() { Instructions = "You are a helpful assistant." },
            AIContextProviders = [skillsProvider],
        },
        model: deploymentName,
        services: serviceProvider);

使用 DI 的代码定义技能

声明 IServiceProvider 作为 AddResource 或 AddScript 委托中的参数——当代理读取资源或运行脚本时，框架会自动解析并注入它。

var distanceSkill = new AgentInlineSkill(
    name: "distance-converter",
    description: "Convert between distance units (miles and kilometers).",
    instructions: """
        Use this skill when the user asks to convert between miles and kilometers.
        1. Read the distance-table resource for conversion factors.
        2. Use the convert script to compute the result.
        """)
    .AddResource("distance-table", (IServiceProvider sp) =>
    {
        return sp.GetRequiredService<ConversionService>().GetDistanceTable();
    })
    .AddScript("convert", (double value, double factor, IServiceProvider sp) =>
    {
        return sp.GetRequiredService<ConversionService>().Convert(value, factor);
    });

使用 DI 的基于类的技能

使用 [AgentSkillResource] 或 [AgentSkillScript] 注解方法，并声明一个 IServiceProvider 参数 - 框架通过反射发现这些成员，从而自动注入服务提供器：

internal sealed class WeightConverterSkill : AgentClassSkill<WeightConverterSkill>
{
    public override AgentSkillFrontmatter Frontmatter { get; } = new(
        "weight-converter",
        "Convert between weight units (pounds and kilograms).");

    protected override string Instructions => """
        Use this skill when the user asks to convert between pounds and kilograms.
        1. Read the weight-table resource for conversion factors.
        2. Use the convert script to compute the result.
        """;

    [AgentSkillResource("weight-table")]
    [Description("Lookup table of multiplication factors for weight conversions.")]
    private static string GetWeightTable(IServiceProvider serviceProvider)
    {
        return serviceProvider.GetRequiredService<ConversionService>().GetWeightTable();
    }

    [AgentSkillScript("convert")]
    [Description("Multiplies a value by a conversion factor and returns the result as JSON.")]
    private static string Convert(double value, double factor, IServiceProvider serviceProvider)
    {
        return serviceProvider.GetRequiredService<ConversionService>().Convert(value, factor);
    }
}

services.AddSingleton<WeightConverterSkill>();
var weightSkill = serviceProvider.GetRequiredService<WeightConverterSkill>();

接受 **kwargs 自动接收传递给 agent.run()的运行时关键字参数的资源和脚本函数。 这样，技能函数就可以访问应用程序上下文（例如配置、用户标识或服务客户端），而无需将它们硬编码到技能定义中。

传递运行时参数

向function_invocation_kwargs传递agent.run()，以提供由框架转发到资源和脚本函数的关键字参数。

response = await agent.run(
    "How many kilometers is 26.2 miles?",
    function_invocation_kwargs={"precision": 2, "user_id": "alice"},
)

具有 kwargs 的资源函数

当资源函数声明 **kwargs时，框架每次代理读取资源时都会转发运行时关键字参数：

from typing import Any
from agent_framework import Skill

project_info_skill = Skill(
    name="project-info",
    description="Project status and configuration information",
    content="Use this skill for questions about the current project.",
)

@project_info_skill.resource(name="environment", description="Current environment configuration")
def environment(**kwargs: Any) -> Any:
    """Return environment config, optionally scoped to a user."""
    user_id = kwargs.get("user_id", "anonymous")
    env = os.environ.get("APP_ENV", "development")
    return f"Environment: {env}, Caller: {user_id}"

不带**kwargs的资源函数无需参数，且不会接收运行时上下文。

使用 kwargs 编写函数脚本

当脚本函数声明 **kwargs 时，框架会将运行时关键字参数与代理提供的 args 一起转发：

import json
from typing import Any
from agent_framework import Skill

converter_skill = Skill(
    name="unit-converter",
    description="Convert between common units using a conversion factor",
    content="Use the convert script to perform unit conversions.",
)

@converter_skill.script(name="convert", description="Convert a value: result = value × factor")
def convert_units(value: float, factor: float, **kwargs: Any) -> str:
    """Convert a value using a multiplication factor.

    Args:
        value: The numeric value to convert (provided by the agent).
        factor: Conversion factor (provided by the agent).
        **kwargs: Runtime keyword arguments from agent.run().
    """
    precision = kwargs.get("precision", 4)
    result = round(value * factor, precision)
    return json.dumps({"value": value, "factor": factor, "result": result})

代理通过工具调用提供value 和factor；应用程序通过function_invocation_kwargs 提供precision。 未包含 **kwargs 的脚本函数仅接收代理提供的参数。