模型切换

会话会使用你在 model 选项中传入的模型运行。先声明一次智能体可以访问的所有模型，然后为每个会话选择其一——用快速模型处理高频、低风险的工作，用能力更强的模型进行评审。当你希望在不改动任何提示词的前提下，于成本与能力之间取得平衡时，可以使用这种方式。

声明模型

模型在智能体文件中配置。每个 provider 列出它对外暴露的模型，当会话未设置 model 时则使用 default_model。

ACL

default_model = "provider/fast-model"

providers "provider" {
  apiKey = env("PROVIDER_API_KEY")
  baseUrl = env("PROVIDER_BASE_URL")

  models "fast-model" { tool_call = true }
  models "review-model" { tool_call = true }
}

按会话设置模型

model 选项在打开会话时设置。该会话运行的一切——send、run、task、 parallel、pipeline——都会使用该模型。同一个智能体配置可以为不同会话驱动不同的模型选择。

Rust

Node.js

Python

Rust

use a3s_code_core::{Agent, SessionOptions};

#[tokio::main]
async fn main() -> a3s_code_core::Result<()> {
    let agent = Agent::new("agent.acl").await?;

    let fast = agent
        .session_builder("/repo")
        .options(SessionOptions::new().with_model("provider/fast-model"))
        .build()
        .await?;
    let draft = fast
        .send("为这个项目起草一段简短的 README 介绍。", None)
        .await?
        .text;
    println!("草稿：{draft}");
    fast.close().await;

    let review = agent
        .session_builder("/repo")
        .options(SessionOptions::new().with_model("provider/review-model"))
        .build()
        .await?;
    let critique = review
        .send(&format!("审查这段 README 介绍：\n{draft}"), None)
        .await?;
    println!("审查意见：{}", critique.text);

    review.close().await;
    agent.close().await;
    Ok(())
}

TypeScript

import { Agent } from '@a3s-lab/code';

const agent = await Agent.create('agent.acl');

// 快速模型用于高频、低风险工作。
const fast = agent.session('/repo', { model: 'provider/fast-model' });
const draft = await fast.run('Draft a short README intro for this project.');
console.log('draft:', draft);
await fast.close();

// 更强的模型用于审查或风险更高的推理。
const review = agent.session('/repo', { model: 'provider/review-model' });
const critique = await review.run(`Critique this README intro:\n${draft}`);
console.log('critique:', critique);
await review.close();

Python

from a3s_code import Agent, SessionOptions

agent = Agent.create("agent.acl")

# 快速模型用于高频、低风险工作。
fast_opts = SessionOptions()
fast_opts.model = 'provider/fast-model'
fast = agent.session('/repo', fast_opts)
draft = fast.run('Draft a short README intro for this project.')
print('draft:', draft)
fast.close()

# 更强的模型用于审查或风险更高的推理。
review_opts = SessionOptions()
review_opts.model = 'provider/review-model'
review = agent.session('/repo', review_opts)
critique = review.run(f'Critique this README intro:\n{draft}')
print('critique:', critique)
review.close()

package main

import (
	"context"
	"fmt"
	"log"

	code "github.com/A3S-Lab/Code/sdk/go/v6"
)

func main() {
	ctx := context.Background()
	agent, err := code.Create(ctx, "agent.acl")
	if err != nil {
		log.Fatal(err)
	}
	defer agent.Close(context.Background())

	fast, err := agent.Session(ctx, "/repo", &code.SessionOptions{
		Model: "provider/fast-model",
	})
	if err != nil {
		log.Fatal(err)
	}
	draft, err := fast.Run(ctx, "为这个项目起草一段简短的 README 介绍。")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("草稿：", draft.Text)
	fast.Close(ctx)

	review, err := agent.Session(ctx, "/repo", &code.SessionOptions{
		Model: "provider/review-model",
	})
	if err != nil {
		log.Fatal(err)
	}
	defer review.Close(context.Background())
	critique, err := review.Run(ctx, "审查这段 README 介绍：\n"+draft.Text)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("审查意见：", critique.Text)
}

按工作智能体覆盖模型

worker 智能体通过各自的规格进行注册。为某个 worker 指定自己的 model，即可让它运行在与委派它的会话不同（通常更小、更廉价）的模型上。编排会话保留自己的 model，只有被委派出去的工作才会运行在该 worker 的模型上。

Rust

Node.js

Python

Rust

use a3s_code_core::{
    subagent::ModelConfig as WorkerModelConfig, Agent, SessionOptions, WorkerAgentSpec,
};
use serde_json::json;

#[tokio::main]
async fn main() -> a3s_code_core::Result<()> {
    let agent = Agent::new("agent.acl").await?;

    let mut scout = WorkerAgentSpec::read_only("scout", "读取文件并报告发现。");
    scout.model = Some(WorkerModelConfig::from_model_ref(
        "provider/fast-model",
    ));
    let session = agent
        .session_builder("/repo")
        .options(
            SessionOptions::new()
                .with_model("provider/review-model")
                .with_worker_agent(scout),
        )
        .build()
        .await?;

    let findings = session
        .tool(
            "task",
            json!({
                "agent": "scout",
                "description": "列出公共 API",
                "prompt": "列出 src/ 中的所有公共 API。"
            }),
        )
        .await?;
    let plan = session
        .send(
            &format!("根据这些发现提出重构方案：\n{}", findings.output),
            None,
        )
        .await?;
    println!("{}", plan.text);

    session.close().await;
    agent.close().await;
    Ok(())
}

TypeScript

import { Agent } from '@a3s-lab/code';

const agent = await Agent.create('agent.acl');

const session = agent.session('/repo', {
  // 编排器继续使用更强的模型。
  model: 'provider/review-model',
  // 高频探索使用成本更低的模型。
  workerAgents: [
    {
      name: 'scout',
      description: 'Reads files and reports findings.',
      model: 'provider/fast-model',
    },
  ],
});

// 把探索委派给低成本工作智能体，再由强模型完成推理。
const findings = await session.task({
  agent: 'scout',
  description: 'List public APIs',
  prompt: 'List every public API in src/.',
});
const plan = await session.run(
  `Given these findings, propose a refactor:\n${findings.output}`,
);
console.log(plan);

session.close();

Python

from a3s_code import Agent, SessionOptions, WorkerAgentSpec

agent = Agent.create("agent.acl")

opts = SessionOptions()
# 编排器继续使用更强的模型。
opts.model = 'provider/review-model'
# 高频探索使用成本更低的模型。
scout = WorkerAgentSpec(
    name='scout',
    description='Reads files and reports findings.',
)
scout.model = 'provider/fast-model'
opts.worker_agents = [scout]
session = agent.session('/repo', opts)

# 把探索委派给低成本工作智能体，再由强模型完成推理。
findings = session.task({
    "agent": "scout",
    "description": "List public APIs",
    "prompt": "List every public API in src/.",
})
plan = session.run(f'Given these findings, propose a refactor:\n{findings.output}')
print(plan)

session.close()

package main

import (
	"context"
	"fmt"
	"log"

	code "github.com/A3S-Lab/Code/sdk/go/v6"
)

func main() {
	ctx := context.Background()
	agent, err := code.Create(ctx, "agent.acl")
	if err != nil {
		log.Fatal(err)
	}
	defer agent.Close(context.Background())

	session, err := agent.Session(ctx, "/repo", &code.SessionOptions{
		Model: "provider/review-model",
	})
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close(context.Background())

	findings, err := session.Task(ctx, code.DelegateTaskOptions{
		Agent:       "explore",
		Description: "列出公共 API",
		Prompt:      "列出 src/ 中的所有公共 API。",
		Model:       "provider/fast-model",
	})
	if err != nil {
		log.Fatal(err)
	}
	plan, err := session.Run(
		ctx,
		"根据这些发现提出重构方案：\n"+findings.Output,
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(plan.Text)
}

说明：

model 的取值是一个标识符字符串，由你的运行时解析为智能体文件中声明的某个模型—— SDK 中没有任何硬编码的模型名称。
worker 智能体的 model 仅作用于该智能体被委派的工作。会话自身的 send/run/task 调用仍使用会话的 model。
未设置 model 的 worker 会继承会话的 model，因此你只需为那些换用不同模型确有收益的智能体进行覆盖即可。

展示会话 model 选项的可运行版本位于 sdk/node/examples/basic/test_api_alignment.ts。

#模型切换

#声明模型

#按会话设置模型

#按工作智能体覆盖模型

模型切换

声明模型

按会话设置模型

按工作智能体覆盖模型