@onco-foundry/agent-template 0.4.1 → 0.6.1

package/dist/agent_spec_executor.d.ts

@@ -0,0 +1,10 @@
+import { type AgentTemplateCard } from './agent_template.ts';
+import type { AgentVersionExecutor } from './agent_version.ts';
+export type AgentSpecExecutorDeclaration<I, O, C = undefined> = {
+    id: string;
+    summary: string;
+    input: AgentTemplateCard<I, O>['input'];
+    output: AgentTemplateCard<I, O>['output'];
+    task: (input: I, context: C) => string;
+};
+export declare const createAgentSpecExecutor: <I, O, C = undefined>(declaration: AgentSpecExecutorDeclaration<I, O, C>) => AgentVersionExecutor<C>;

package/dist/agent_spec_executor.js

@@ -0,0 +1,47 @@
+import { defineAgent } from 'agent-lattice';
+import { createTypedAgentTool } from '@onco-foundry/agent-runtime';
+import { createTracer } from '@onco-foundry/trace-port';
+import { clampThinkingBudgetTokens } from './agent_template.js';
+export const createAgentSpecExecutor = (declaration) => ({
+    card: {
+        name: declaration.id,
+        kind: 'agent',
+        summary: declaration.summary,
+        input: declaration.input,
+        output: declaration.output,
+    },
+    task: declaration.task,
+    async createSpec(input) {
+        const memberTools = await Promise.all(input.members.map(async (member) => createTypedAgentTool(await member.agent.createCapability({
+            tracer: input.tracer,
+            modelClient: input.modelClient,
+        }), {
+            delegation: await member.agent.createDelegation({
+                tracer: input.tracer,
+                modelClient: input.modelClient,
+            }),
+        })));
+        const maxTokens = input.config.limits?.maxTokens;
+        const thinkingBudgetTokens = input.config.limits?.thinkingBudgetTokens;
+        return defineAgent({
+            name: input.agentId.replaceAll('-', '_'),
+            model: input.model.model,
+            baseURL: input.model.baseURL,
+            ...(input.model.apiKey === undefined ? {} : { apiKey: input.model.apiKey }),
+            modelClient: input.modelClient,
+            systemPrompt: input.systemPrompt,
+            outputSchema: declaration.output,
+            tools: [...input.tools, ...memberTools],
+            ...(maxTokens === undefined ? {} : { maxTokens }),
+            maxTurns: input.config.limits?.maxTurns ?? 10,
+            thinkingConfig: thinkingBudgetTokens === undefined
+                ? { type: 'disabled' }
+                : { type: 'enabled', budgetTokens: maxTokens === undefined
+                        ? thinkingBudgetTokens
+                        : clampThinkingBudgetTokens(thinkingBudgetTokens, maxTokens) },
+            ...(input.submitOutputEndTurn === undefined ? {} : { submitOutputEndTurn: input.submitOutputEndTurn }),
+            tracer: input.tracer ?? createTracer({ kind: 'noop' }),
+            workspace: false,
+        });
+    },
+});

package/dist/agent_template.d.ts

@@ -89,8 +89,9 @@ export type AgentTemplateDeclaration<I, O, C = undefined> = {
      */
     promptStore?: VersionedResourceStore;
     /**
-     * 可选限额。缺省：maxTokens 16384、maxTurns 10、thinking 关闭；
-     * thinkingBudgetTokens 给了才开 thinking（按 clampThinkingBudgetTokens 钳制到 maxTokens 以内）。
+     * 可选限额。maxTokens 未给时由 AgentLattice 按模型端点决定默认值；
+     * maxTurns 缺省 10，thinking 缺省关闭。thinkingBudgetTokens 给了才开 thinking；
+     * 显式 maxTokens 时在这里钳制思考预算，否则交给 SDK 按实际输出上限钳制。
      */
     limits?: {
         maxTokens?: number;

package/dist/agent_template.js

@@ -15,8 +15,6 @@ export const promptManifestSchema = z.object({
     provenance: z.string().min(1),
     systemPrompt: resourceFileReferenceSchema,
 });
-/** 缺省输出预算：无工具的问答/判定类交付，16k 足够。 */
-const DEFAULT_MAX_TOKENS = 16_384;
 /** 缺省轮次上限：无工具模板一次 loop 典型路径是读入即交付。 */
 const DEFAULT_MAX_TURNS = 10;
 /**
@@ -103,7 +101,7 @@ export const defineAgentTemplate = (declaration) => {
         const tracer = options.tracer ?? createTracer({ kind: 'noop' });
         // prompt 版本在装配处还不知道，加载完版本化资源后回填进版本链。
         tracer.setVersions({ prompt: promptVersion });
-        const maxTokens = declaration.limits?.maxTokens ?? DEFAULT_MAX_TOKENS;
+        const maxTokens = declaration.limits?.maxTokens;
         const maxTurns = declaration.limits?.maxTurns ?? DEFAULT_MAX_TURNS;
         const thinkingBudgetTokens = declaration.limits?.thinkingBudgetTokens;
         // workspace: false = 裸会话：不装内建工作区工具，同构简单模板不需要文件/Bash 权限面。
@@ -115,11 +113,13 @@ export const defineAgentTemplate = (declaration) => {
             apiKey: options.model.apiKey,
             modelClient: options.modelClient,
             systemPrompt,
-            maxTokens,
+            ...(maxTokens === undefined ? {} : { maxTokens }),
             maxTurns,
             thinkingConfig: thinkingBudgetTokens === undefined
                 ? { type: 'disabled' }
-                : { type: 'enabled', budgetTokens: clampThinkingBudgetTokens(thinkingBudgetTokens, maxTokens) },
+                : { type: 'enabled', budgetTokens: maxTokens === undefined
+                        ? thinkingBudgetTokens
+                        : clampThinkingBudgetTokens(thinkingBudgetTokens, maxTokens) },
             // 无领域校验要过，交付契约直接交给 SDK：声明 outputSchema 后 SDK 注入
             // submit_output 工具，没提交就收尾会以 error_missing_output 失败。
             outputSchema: declaration.output,

package/dist/agent_version.d.ts

@@ -0,0 +1,152 @@
+import type { AgentSpec, ModelClient } from 'agent-lattice';
+import { z } from 'zod';
+import type { Capability } from '@onco-foundry/capability-registry';
+import type { CapabilityDelegation } from '@onco-foundry/agent-runtime';
+import type { Tracer } from '@onco-foundry/trace-port';
+import type { AgentTemplateCard, TemplateToolDefinition } from './agent_template.ts';
+export declare const agentResourceVersionSchema: z.ZodString;
+export declare const agentVersionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"agent-config-v1">;
+    executor: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    model: z.ZodObject<{
+        configVersion: z.ZodString;
+        model: z.ZodString;
+        baseURL: z.ZodURL;
+    }, z.core.$strict>;
+    prompt: z.ZodObject<{
+        resource: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    commonPrompts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodEnum<{
+            card: "card";
+            shared: "shared";
+        }>;
+        version: z.ZodString;
+        placement: z.ZodEnum<{
+            after: "after";
+            before: "before";
+        }>;
+        order: z.ZodNumber;
+        basedOnVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    tools: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"local">;
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    members: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    limits: z.ZodOptional<z.ZodObject<{
+        maxTurns: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        thinkingBudgetTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentVersion = z.infer<typeof agentVersionSchema>;
+export type AgentVersionExecutorReference = AgentVersion['executor'];
+export type AgentVersionModel = AgentVersion['model'];
+export type AgentVersionPromptReference = AgentVersion['prompt'];
+export type AgentVersionCommonPromptReference = AgentVersion['commonPrompts'][number];
+export type AgentVersionToolReference = AgentVersion['tools'][number];
+export type AgentVersionMemberReference = AgentVersion['members'][number];
+export type ResolvedAgentModel = AgentVersionModel & {
+    apiKey?: string;
+};
+export type ResolvedAgentVersion = {
+    version: string;
+    checksum: string;
+    executorVersion: string;
+    model: AgentVersionModel;
+    prompt: AgentVersionPromptReference & {
+        checksum: string;
+    };
+    systemPromptChecksum: string;
+    commonPrompts: Array<AgentVersionCommonPromptReference & {
+        checksum: string;
+    }>;
+    tools: AgentVersionToolReference[];
+    members: AgentVersionMemberReference[];
+    limits?: AgentVersion['limits'];
+};
+export type ResolvedAgentSnapshot = {
+    root: {
+        id: string;
+        version: string;
+    };
+    agents: Record<string, ResolvedAgentVersion>;
+    overrides?: {
+        promptVersion?: string;
+        memberPromptVersions?: Record<string, string>;
+    };
+    configurationFingerprint: string;
+};
+export type CreateResolvedAgentSpecOptions = {
+    tracer?: Tracer;
+    modelClient?: ModelClient;
+    submitOutputEndTurn?: boolean;
+};
+export type ResolvedAgent = {
+    createSpec(options?: CreateResolvedAgentSpecOptions): Promise<AgentSpec>;
+    createDelegation(options?: CreateResolvedAgentSpecOptions): Promise<CapabilityDelegation>;
+    createCapability(options?: CreateResolvedAgentSpecOptions): Promise<Capability>;
+    readSystemPrompt(): {
+        content: string;
+        version: string;
+    };
+    readSnapshot(): ResolvedAgentSnapshot;
+};
+export type ResolvedAgentMember = {
+    id: string;
+    version: string;
+    agent: ResolvedAgent;
+};
+export type AgentExecutorSpecInput<C> = {
+    agentId: string;
+    config: AgentVersion;
+    model: ResolvedAgentModel;
+    systemPrompt: string;
+    tools: TemplateToolDefinition[];
+    members: ResolvedAgentMember[];
+    context: C;
+    tracer?: Tracer;
+    modelClient?: ModelClient;
+    submitOutputEndTurn?: boolean;
+};
+export type AgentVersionExecutor<C = unknown> = {
+    readonly card: AgentTemplateCard;
+    readonly task: (input: any, context: C) => string;
+    validate?(input: {
+        agentId: string;
+        config: AgentVersion;
+    }): void;
+    createSpec(input: AgentExecutorSpecInput<C>): Promise<AgentSpec>;
+};
+export type AgentVersionPorts<C = unknown> = {
+    storeFor(agentId: string): import('@onco-foundry/resource-versioning').VersionedResourceStore;
+    resolveModel(reference: AgentVersionModel): Promise<{
+        apiKey?: string;
+    }>;
+    readPrompt(reference: AgentVersionPromptReference): Promise<{
+        content: string;
+    }>;
+    readCommonPrompt(reference: AgentVersionCommonPromptReference): Promise<{
+        content: string;
+    }>;
+    createTool(reference: AgentVersionToolReference, context: C): TemplateToolDefinition | Promise<TemplateToolDefinition>;
+    resolveExecutor(reference: AgentVersionExecutorReference): AgentVersionExecutor<C>;
+};
+export type ResolveAgentVersionInput<C = unknown> = {
+    agentId: string;
+    version?: string;
+    context: C;
+    promptVersion?: string;
+    memberPromptVersions?: Record<string, string>;
+};

package/dist/agent_version.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+export const agentResourceVersionSchema = z.string().regex(/^v[1-9]\d{0,8}$/, '版本必须形如 v15');
+const executorReferenceSchema = z.object({
+    id: z.string().min(1),
+    version: agentResourceVersionSchema,
+}).strict();
+const promptReferenceSchema = z.object({
+    resource: z.string().min(1),
+    version: agentResourceVersionSchema,
+}).strict();
+const commonPromptReferenceSchema = z.object({
+    id: z.string().min(1),
+    source: z.enum(['shared', 'card']),
+    version: agentResourceVersionSchema,
+    placement: z.enum(['before', 'after']),
+    order: z.number().int().min(1).max(1000),
+    basedOnVersion: agentResourceVersionSchema.optional(),
+}).strict();
+const localToolReferenceSchema = z.object({
+    type: z.literal('local'),
+    id: z.string().min(1),
+    version: agentResourceVersionSchema,
+}).strict();
+const memberReferenceSchema = z.object({
+    type: z.literal('agent'),
+    id: z.string().min(1),
+    version: agentResourceVersionSchema,
+}).strict();
+export const agentVersionSchema = z.object({
+    schemaVersion: z.literal('agent-config-v1'),
+    executor: executorReferenceSchema,
+    model: z.object({
+        configVersion: z.string().min(1),
+        model: z.string().min(1),
+        baseURL: z.url().refine(value => {
+            const url = new URL(value);
+            return url.username === '' && url.password === '';
+        }, '模型 baseURL 不能包含凭据'),
+    }).strict(),
+    prompt: promptReferenceSchema,
+    commonPrompts: z.array(commonPromptReferenceSchema),
+    tools: z.array(localToolReferenceSchema),
+    members: z.array(memberReferenceSchema),
+    limits: z.object({
+        maxTurns: z.number().int().positive().optional(),
+        maxTokens: z.number().int().min(2).optional(),
+        thinkingBudgetTokens: z.number().int().positive().optional(),
+    }).strict().optional(),
+}).strict();

package/dist/agent_version_resolver.d.ts

@@ -0,0 +1,4 @@
+import { type AgentVersionPorts, type ResolveAgentVersionInput, type ResolvedAgent } from './agent_version.ts';
+export declare const createAgentVersionResolver: <C>(ports: AgentVersionPorts<C>) => {
+    resolve: (input: ResolveAgentVersionInput<C>) => Promise<ResolvedAgent>;
+};

package/dist/agent_version_resolver.js

@@ -0,0 +1,188 @@
+import { createHash } from 'node:crypto';
+import { AppError } from '@onco-foundry/errors';
+import { defineCapability } from '@onco-foundry/capability-registry';
+import { loadActiveVersionedResource, versionedFilesManifestSchema, } from '@onco-foundry/resource-versioning';
+import { agentVersionSchema, } from './agent_version.js';
+const checksum = (content) => createHash('sha256').update(content).digest('hex');
+export const createAgentVersionResolver = (ports) => {
+    const loadConfig = async (agentId, version) => {
+        const resource = await loadActiveVersionedResource({
+            store: ports.storeFor(agentId),
+            manifestSchema: versionedFilesManifestSchema,
+            ...(version === undefined ? {} : { versionOverride: version }),
+        });
+        const raw = resource.files.get('agent.json');
+        if (raw === undefined)
+            throw new AppError(`智能体 ${agentId} 的 ${resource.version} 缺少 agent.json`);
+        return {
+            config: agentVersionSchema.parse(JSON.parse(raw)),
+            version: resource.version,
+            configChecksum: checksum(raw),
+        };
+    };
+    const resolve = async (input) => {
+        const records = new Map();
+        const visiting = new Set();
+        const snapshotFor = (rootId) => {
+            const agents = {};
+            const collect = (id) => {
+                if (agents[id] !== undefined)
+                    return;
+                const record = records.get(id);
+                if (record === undefined)
+                    throw new AppError(`智能体 ${id} 的解析记录不存在`);
+                agents[id] = {
+                    version: record.version,
+                    checksum: record.configChecksum,
+                    executorVersion: record.config.executor.version,
+                    model: { ...record.config.model },
+                    prompt: { ...record.prompt },
+                    systemPromptChecksum: record.systemPromptChecksum,
+                    commonPrompts: record.commonPrompts.map(({ content: _content, ...part }) => ({ ...part })),
+                    tools: record.config.tools.map(tool => ({ ...tool })),
+                    members: record.config.members.map(member => ({ ...member })),
+                    ...(record.config.limits === undefined ? {} : { limits: { ...record.config.limits } }),
+                };
+                for (const member of record.config.members)
+                    collect(member.id);
+            };
+            collect(rootId);
+            const orderedAgents = Object.fromEntries(Object.keys(agents).sort().map(id => [id, agents[id]]));
+            const root = records.get(rootId);
+            if (root === undefined)
+                throw new AppError(`智能体 ${rootId} 的解析记录不存在`);
+            const overrides = input.promptVersion === undefined && input.memberPromptVersions === undefined
+                ? undefined
+                : {
+                    ...(input.promptVersion === undefined ? {} : { promptVersion: input.promptVersion }),
+                    ...(input.memberPromptVersions === undefined ? {} : { memberPromptVersions: { ...input.memberPromptVersions } }),
+                };
+            const configurationFingerprint = checksum(JSON.stringify({
+                root: { id: rootId, version: root.version },
+                agents: orderedAgents,
+                ...(overrides === undefined ? {} : { overrides }),
+            }));
+            return {
+                root: { id: rootId, version: root.version },
+                agents: orderedAgents,
+                ...(overrides === undefined ? {} : { overrides }),
+                configurationFingerprint,
+            };
+        };
+        const visit = async (agentId, version) => {
+            if (visiting.has(agentId))
+                throw new AppError(`智能体版本图存在循环引用：${agentId}`);
+            const loaded = await loadConfig(agentId, version);
+            const existing = records.get(agentId);
+            if (existing !== undefined) {
+                if (existing.version !== loaded.version) {
+                    throw new AppError(`智能体 ${agentId} 在同一版本图中引用了不同版本：${existing.version}、${loaded.version}`);
+                }
+                if (existing.agent !== undefined)
+                    return existing.agent;
+            }
+            visiting.add(agentId);
+            try {
+                const executor = ports.resolveExecutor(loaded.config.executor);
+                executor.validate?.({ agentId, config: loaded.config });
+                const promptVersion = agentId === input.agentId
+                    ? input.promptVersion
+                    : input.memberPromptVersions?.[agentId];
+                const promptReference = {
+                    ...loaded.config.prompt,
+                    ...(promptVersion === undefined ? {} : { version: agentVersionSchema.shape.prompt.shape.version.parse(promptVersion) }),
+                };
+                const [prompt, modelCredential] = await Promise.all([
+                    ports.readPrompt(promptReference),
+                    ports.resolveModel(loaded.config.model),
+                ]);
+                const commonPrompts = await Promise.all(loaded.config.commonPrompts.map(async (reference) => {
+                    const { content } = await ports.readCommonPrompt(reference);
+                    return { ...reference, content, checksum: checksum(content) };
+                }));
+                const ordered = [...commonPrompts].sort((a, b) => a.placement === b.placement
+                    ? a.order - b.order || a.id.localeCompare(b.id)
+                    : a.placement === 'before' ? -1 : 1);
+                const before = ordered.filter(part => part.placement === 'before');
+                const after = ordered.filter(part => part.placement === 'after');
+                const systemPrompt = [
+                    ...before.map(part => part.content),
+                    prompt.content,
+                    ...after.map(part => part.content),
+                ].join('\n\n');
+                const record = {
+                    id: agentId,
+                    version: loaded.version,
+                    configChecksum: loaded.configChecksum,
+                    config: loaded.config,
+                    executor,
+                    model: { ...loaded.config.model, ...modelCredential },
+                    prompt: { ...promptReference, checksum: checksum(prompt.content) },
+                    commonPrompts,
+                    systemPrompt,
+                    systemPromptChecksum: checksum(systemPrompt),
+                };
+                records.set(agentId, record);
+                const createSpec = async (options = {}) => {
+                    options.tracer?.setVersions({
+                        template: `${agentId}@${record.version}`,
+                        prompt: `${record.prompt.resource}/${record.prompt.version}`,
+                        model: record.model.model,
+                    });
+                    const tools = await Promise.all(record.config.tools.map(reference => ports.createTool(reference, input.context)));
+                    return await record.executor.createSpec({
+                        agentId,
+                        config: record.config,
+                        model: record.model,
+                        systemPrompt: record.systemPrompt,
+                        tools,
+                        members: await Promise.all(record.config.members.map(async (member) => ({
+                            id: member.id,
+                            version: member.version,
+                            agent: await visit(member.id, member.version),
+                        }))),
+                        context: input.context,
+                        ...(options.tracer === undefined ? {} : { tracer: options.tracer }),
+                        ...(options.modelClient === undefined ? {} : { modelClient: options.modelClient }),
+                        ...(options.submitOutputEndTurn === undefined ? {} : { submitOutputEndTurn: options.submitOutputEndTurn }),
+                    });
+                };
+                const agent = {
+                    createSpec,
+                    createDelegation: async (options) => ({
+                        spec: await createSpec(options),
+                        mapInput: rawInput => record.executor.task(rawInput, input.context),
+                    }),
+                    createCapability: async (options) => {
+                        const spec = await createSpec(options);
+                        return defineCapability({
+                            ...record.executor.card,
+                            version: record.version,
+                            run: async (rawInput) => {
+                                const parsedInput = record.executor.card.input.parse(rawInput);
+                                const response = await spec.spawn().prompt(record.executor.task(parsedInput, input.context));
+                                if (response.is_error)
+                                    throw response.error ?? new Error(`智能体 ${agentId} 运行失败：${response.subtype}`);
+                                if (response.structuredResult === undefined) {
+                                    throw new Error(`智能体 ${agentId} 的模型未提交结构化交付，本次运行不算完成`);
+                                }
+                                return record.executor.card.output.parse(response.structuredResult);
+                            },
+                        });
+                    },
+                    readSystemPrompt: () => ({ content: record.systemPrompt, version: record.prompt.version }),
+                    readSnapshot: () => structuredClone(snapshotFor(agentId)),
+                };
+                record.agent = agent;
+                for (const member of record.config.members)
+                    await visit(member.id, member.version);
+                return agent;
+            }
+            finally {
+                visiting.delete(agentId);
+            }
+        };
+        return await visit(input.agentId, input.version);
+    };
+    return { resolve };
+};

package/dist/fake_agent_version_ports.d.ts

@@ -0,0 +1,12 @@
+import type { TemplateToolDefinition } from './agent_template.ts';
+import type { AgentVersion, AgentVersionCommonPromptReference, AgentVersionExecutor, AgentVersionPorts, AgentVersionPromptReference } from './agent_version.ts';
+export declare const createFakeAgentVersionPorts: <C>(options: {
+    executors: Record<string, AgentVersionExecutor<C>>;
+    modelApiKey?: string;
+    tools?: Record<string, (context: C) => TemplateToolDefinition>;
+}) => AgentVersionPorts<C> & {
+    writeAgentVersion(agentId: string, version: string, config: AgentVersion, activate?: boolean): Promise<void>;
+    activateAgentVersion(agentId: string, version: string): Promise<void>;
+    setPrompt(reference: AgentVersionPromptReference, content: string): void;
+    setCommonPrompt(reference: AgentVersionCommonPromptReference, content: string): void;
+};

package/dist/fake_agent_version_ports.js

@@ -0,0 +1,65 @@
+import { AppError } from '@onco-foundry/errors';
+import { activateVersion, createFakeVersionedResourceStore, createVersionedResource, } from '@onco-foundry/resource-versioning';
+const promptKey = (reference) => `${reference.resource}@${reference.version}`;
+const commonPromptKey = (reference) => `${reference.source}:${reference.id}@${reference.version}`;
+const executorKey = (reference) => `${reference.id}@${reference.version}`;
+const toolKey = (reference) => `${reference.id}@${reference.version}`;
+export const createFakeAgentVersionPorts = (options) => {
+    const stores = new Map();
+    const prompts = new Map();
+    const commonPrompts = new Map();
+    const ports = {
+        storeFor(agentId) {
+            let store = stores.get(agentId);
+            if (store === undefined) {
+                store = createFakeVersionedResourceStore();
+                stores.set(agentId, store);
+            }
+            return store;
+        },
+        resolveModel: async () => options.modelApiKey === undefined ? {} : { apiKey: options.modelApiKey },
+        readPrompt: async (reference) => {
+            const content = prompts.get(promptKey(reference));
+            if (content === undefined)
+                throw new AppError(`fake prompt 不存在：${promptKey(reference)}`);
+            return { content };
+        },
+        readCommonPrompt: async (reference) => {
+            const content = commonPrompts.get(commonPromptKey(reference));
+            if (content === undefined)
+                throw new AppError(`fake 共同 prompt 不存在：${commonPromptKey(reference)}`);
+            return { content };
+        },
+        createTool(reference, context) {
+            const create = options.tools?.[toolKey(reference)];
+            if (create === undefined)
+                throw new AppError(`fake 工具不存在：${toolKey(reference)}`);
+            return create(context);
+        },
+        resolveExecutor(reference) {
+            const executor = options.executors[executorKey(reference)];
+            if (executor === undefined)
+                throw new AppError(`fake 执行器不存在：${executorKey(reference)}`);
+            return executor;
+        },
+        async writeAgentVersion(agentId, version, config, activate = true) {
+            await createVersionedResource({
+                store: ports.storeFor(agentId),
+                version,
+                files: { 'agent.json': JSON.stringify(config) },
+            });
+            if (activate)
+                await ports.activateAgentVersion(agentId, version);
+        },
+        activateAgentVersion: async (agentId, version) => {
+            await activateVersion({ store: ports.storeFor(agentId), version });
+        },
+        setPrompt(reference, content) {
+            prompts.set(promptKey(reference), content);
+        },
+        setCommonPrompt(reference, content) {
+            commonPrompts.set(commonPromptKey(reference), content);
+        },
+    };
+    return ports;
+};

package/dist/index.d.ts

@@ -1,2 +1,6 @@
 export { clampThinkingBudgetTokens, defineAgentTemplate, promptManifestSchema, type AgentTemplate, type AgentTemplateCard, type AgentTemplateDeclaration, type CreateTemplateAgentOptions, type PromptManifestAdapter, type TemplateToolDefinition, } from './agent_template.ts';
 export type { CapabilityDelegation } from '@onco-foundry/agent-runtime';
+export { createAgentSpecExecutor, type AgentSpecExecutorDeclaration } from './agent_spec_executor.ts';
+export { agentResourceVersionSchema, agentVersionSchema, type AgentVersion, type AgentVersionCommonPromptReference, type AgentVersionExecutor, type AgentVersionExecutorReference, type AgentVersionMemberReference, type AgentVersionModel, type AgentVersionPorts, type AgentVersionPromptReference, type AgentVersionToolReference, type CreateResolvedAgentSpecOptions, type ResolveAgentVersionInput, type ResolvedAgent, type ResolvedAgentMember, type ResolvedAgentModel, type ResolvedAgentSnapshot, type ResolvedAgentVersion, } from './agent_version.ts';
+export { createAgentVersionResolver } from './agent_version_resolver.ts';
+export { createFakeAgentVersionPorts } from './fake_agent_version_ports.ts';

package/dist/index.js

@@ -1 +1,5 @@
 export { clampThinkingBudgetTokens, defineAgentTemplate, promptManifestSchema, } from './agent_template.js';
+export { createAgentSpecExecutor } from './agent_spec_executor.js';
+export { agentResourceVersionSchema, agentVersionSchema, } from './agent_version.js';
+export { createAgentVersionResolver } from './agent_version_resolver.js';
+export { createFakeAgentVersionPorts } from './fake_agent_version_ports.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onco-foundry/agent-template",
-  "version": "0.4.1",
+  "version": "0.6.1",
   "type": "module",
   "files": [
     "dist"
@@ -15,10 +15,10 @@
     "agent-lattice": "0.26.0",
     "zod": "^4.4.3",
     "@onco-foundry/agent-runtime": "0.3.0",
-    "@onco-foundry/errors": "0.1.1",
     "@onco-foundry/capability-registry": "0.1.1",
+    "@onco-foundry/resource-versioning": "0.3.0",
     "@onco-foundry/trace-port": "0.3.3",
-    "@onco-foundry/resource-versioning": "0.3.0"
+    "@onco-foundry/errors": "0.1.1"
   },
   "publishConfig": {
     "access": "public"