@springbrand/agent-runtime 0.1.3-alpha.0 → 0.1.3-alpha.10

package/src/runtime-assembler.ts

@@ -0,0 +1,797 @@
+import type { SkillSource } from "agents/skills";
+import type {
+  RuntimeCodeExecutionPort,
+  RuntimeGatewayPort,
+  RuntimeMemoryPort,
+  RuntimePlatformPort,
+  RuntimeProviderPort,
+  RuntimeSandboxPort,
+  RuntimeSchedulePort,
+  RuntimeSkillSourceBinding,
+  RuntimeSubagentPort,
+  RuntimeTurnEventsPort,
+  RuntimeBindings,
+  RuntimeSkillScriptPolicy,
+  WorkspacePort,
+} from "./kernel/bindings";
+import {
+  freezeRuntimeProfile,
+  type RuntimeDenyPolicy,
+  type RuntimeMcpServer,
+  type RuntimeMemoryProfile,
+  type RuntimeProfile,
+  type ThinkingEffort,
+} from "./kernel/profile";
+import type { RuntimeExtensionConfig } from "./kernel/extensions";
+import type { RuntimeDegradation } from "./kernel/degradation";
+import {
+  EXECUTION_LEVELS,
+  type ExecutionLevel,
+} from "./lib/execution-level";
+import {
+  createPiRuntimeAssembly,
+  type PiToolSurface,
+  type PiRuntimeAssembly,
+} from "./pi/assembly/snapshot";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import type { PiToolCandidate } from "./pi/tool/compiler";
+import type {
+  AssembleRuntimeSnapshotInput,
+  RuntimeAgentHooks,
+  RuntimeSettings,
+  RuntimeExtensionContribution,
+  RuntimeProfileContribution,
+  RuntimeSkillContribution,
+  RuntimeToolSurfacePolicy,
+} from "./runtime-definition";
+import type { ToolRegistry } from "./tool-registry";
+import { withRuntimeLoadTimeout } from "./kernel/runtime-load";
+import {
+  basePiToolCandidates,
+  memoryPiToolCandidate,
+} from "./pi/tool/base";
+import {
+  browserQuickActionPiToolCandidates,
+} from "./pi/tool/core";
+import { skillPiToolCandidates } from "./pi/tool/skill";
+import { createWebSearch } from "./pi/tool/web-search";
+import { resolvePiModel } from "./pi/runtime-adapter/models";
+
+/** Runtime Assembler：校验一份扁平输入并生成可原子提交的 Snapshot。 */
+
+export type { RuntimeDegradation } from "./kernel/degradation";
+export type {
+  RuntimeExtensionContribution,
+  RuntimeProfileContribution,
+  RuntimeSkillContribution,
+  RuntimeToolSurfacePolicy,
+} from "./runtime-definition";
+
+/** Host Planner 与 Runtime Assembler 之间的一次性内部 seam。 */
+export interface RuntimeAssemblyInput {
+  readonly profile: RuntimeProfileContribution;
+  readonly memoryProfile: RuntimeMemoryProfile;
+  readonly toolPolicy?: RuntimeToolSurfacePolicy;
+  readonly enabledSubagents: readonly string[];
+  readonly provider: RuntimeProviderPort;
+  readonly platform: RuntimePlatformPort;
+  readonly workspace?: WorkspacePort;
+  readonly codeExecution?: RuntimeCodeExecutionPort;
+  readonly sandbox?: RuntimeSandboxPort;
+  readonly memory?: RuntimeMemoryPort;
+  readonly hostTools: readonly PiToolCandidate[];
+  readonly skills: readonly RuntimeSkillContribution[];
+  readonly connectors: readonly RuntimeMcpServer[];
+  readonly gateway?: RuntimeGatewayPort;
+  readonly extensions: readonly RuntimeExtensionContribution[];
+  readonly subagents?: RuntimeSubagentPort;
+  readonly schedule?: RuntimeSchedulePort;
+  readonly turnEvents?: RuntimeTurnEventsPort;
+  readonly commitGuards: readonly (() => Promise<void>)[];
+  readonly degradations: readonly RuntimeDegradation[];
+}
+
+// #region 内部候选契约
+
+/**
+ * 保存一次已经完成校验、可供 Kernel 使用的 Runtime 结果。
+ *
+ * @internal
+ */
+export interface RuntimeSnapshot {
+  readonly profile: RuntimeProfile;
+  readonly bindings: RuntimeBindings;
+  readonly pi: PiRuntimeAssembly;
+  readonly degradations: readonly RuntimeDegradation[];
+}
+
+/**
+ * 保存待提交的 Snapshot 和提交前检查。
+ *
+ * @internal
+ */
+export interface RuntimeCandidate {
+  readonly snapshot: RuntimeSnapshot;
+  readonly commitGuards: readonly (() => Promise<void>)[];
+  readonly hooks?: RuntimeAgentHooks<Cloudflare.Env, unknown, never, never>;
+  readonly turnEvents?: RuntimeTurnEventsPort;
+}
+
+const DISABLED_MEMORY: RuntimeMemoryProfile = Object.freeze({
+  enabled: false,
+  memoryTokens: 2_000,
+  preferencesTokens: 500,
+});
+
+// 作用：把外部名称整理成非空字符串。
+// 调用：Builder 在添加具名 Tool、Skill、Connector 或 Extension 时调用。
+// 原因：统一在入口拒绝空名称，后续 Map 和 Set 才有稳定键值。
+function requiredName(value: string, label: string): string {
+  const name = value.trim();
+  if (!name) throw new Error(`${label} name must not be empty`);
+  return name;
+}
+
+// 作用：检查内存预算都是可用的非负数字。
+// 调用：Builder 在生成候选 Snapshot 前调用。
+// 原因：把检查放在提交前，失败时旧 Snapshot 仍保持不变。
+function assertMemoryProfile(profile: RuntimeMemoryProfile): void {
+  for (const [name, value] of Object.entries(profile)) {
+    if (name === "enabled") continue;
+    if (
+      typeof value !== "number" ||
+      !Number.isFinite(value) ||
+      value < 0
+    ) {
+      throw new Error(`Runtime memory ${name} must be a non-negative number`);
+    }
+  }
+}
+
+interface ToolSurfaceInput {
+  readonly platform: RuntimePlatformPort;
+  readonly workspace?: WorkspacePort;
+  readonly memory?: {
+    readonly port: RuntimeMemoryPort;
+    readonly profile: RuntimeMemoryProfile;
+  };
+  readonly hostTools: readonly PiToolCandidate[];
+  readonly skills: readonly RuntimeSkillSourceBinding[];
+  readonly enabledSubagents: readonly string[];
+  readonly webSearch: Parameters<typeof basePiToolCandidates>[0];
+  readonly extensions: readonly RuntimeExtensionConfig[];
+  readonly policy?: RuntimeToolSurfacePolicy;
+}
+
+interface ToolSurface {
+  readonly surface: PiToolSurface;
+  readonly extensions: readonly RuntimeExtensionConfig[];
+  readonly degradations: readonly RuntimeDegradation[];
+}
+
+// 唯一 Tool Surface seam：只读取已配置 Port、Resource 和 Agent policy，
+// 统一生成可见 Tool，并在一处做名称、执行档位与冲突校验。
+async function createToolSurface(
+  input: ToolSurfaceInput,
+): Promise<ToolSurface> {
+  const deny = new Set(input.policy?.denyPolicy?.deny ?? []);
+  const allowsTool = input.policy?.allowsTool;
+  const allowsExtension = input.policy?.allowsExtension;
+  const visible = (candidate: PiToolCandidate) =>
+    !deny.has(candidate.tool.name) &&
+    allowsTool?.(candidate.tool.name) !== false;
+  const browserCandidates = input.platform.browser
+    ? browserQuickActionPiToolCandidates(input.platform.browser)
+    : [];
+  const baseCandidates = basePiToolCandidates(input.webSearch);
+  const memoryCandidates = input.memory
+    ? [memoryPiToolCandidate(input.memory.port, input.memory.profile)]
+    : [];
+  const scriptCandidates = [
+    ...browserCandidates,
+    ...input.hostTools,
+    ...baseCandidates,
+    ...memoryCandidates,
+  ].filter(visible);
+  const staticCandidates = [
+    ...browserCandidates,
+    ...input.hostTools,
+    ...(await skillPiToolCandidates(input.skills, {
+      loader: input.platform.loader,
+      ...(input.workspace ? { workspace: input.workspace } : {}),
+      tools: scriptCandidates,
+    })),
+    ...baseCandidates,
+    ...memoryCandidates,
+  ];
+
+  return {
+    surface: Object.freeze({
+      finalize(candidates: readonly PiToolCandidate[]) {
+        const tools = new Map<string, PiToolCandidate>();
+
+        for (const candidate of [
+          ...staticCandidates,
+          ...candidates,
+        ]) {
+          const name = requiredName(candidate.tool.name, "Pi Tool");
+          if (!visible(candidate)) continue;
+          if (!EXECUTION_LEVELS.includes(candidate.requiredExecutionLevel)) {
+            throw new Error(`Pi Tool ${name} execution level is invalid`);
+          }
+          if (tools.has(name)) {
+            throw new Error(`Duplicate Runtime Pi Tool: ${name}`);
+          }
+          tools.set(name, Object.freeze({ ...candidate }));
+        }
+
+        return Object.freeze([...tools.values()]);
+      },
+    }),
+    extensions: input.extensions.filter(
+      (extension) => allowsExtension?.(extension) !== false,
+    ),
+    degradations: [],
+  };
+}
+
+// #endregion
+
+// #region RuntimeBuilder 合并
+
+class RuntimeBuilder {
+  private profile?: RuntimeProfileContribution;
+  private provider?: RuntimeProviderPort;
+  private platform?: RuntimePlatformPort;
+  private gateway?: RuntimeGatewayPort;
+  private workspace?: WorkspacePort;
+  private codeExecution?: RuntimeCodeExecutionPort;
+  private sandbox?: RuntimeSandboxPort;
+  private schedule?: RuntimeSchedulePort;
+  private memoryProfile: RuntimeMemoryProfile = DISABLED_MEMORY;
+  private memory?: RuntimeMemoryPort;
+  private readonly hostTools: PiToolCandidate[] = [];
+  private toolPolicy?: RuntimeToolSurfacePolicy;
+  private readonly skillSources = new Map<
+    string,
+    {
+      name: string;
+      description: string;
+      source: SkillSource;
+      script: RuntimeSkillScriptPolicy;
+    }
+  >();
+  private readonly connectors = new Map<string, RuntimeMcpServer>();
+  private readonly extensions = new Map<string, RuntimeExtensionConfig>();
+  private readonly enabledSubagents = new Set<string>();
+  private subagents?: RuntimeSubagentPort;
+  private turnEvents?: RuntimeTurnEventsPort;
+  private readonly commitGuards: Array<() => Promise<void>> = [];
+  private readonly degradations: RuntimeDegradation[] = [];
+
+  merge(input: RuntimeAssemblyInput): void {
+    for (const degradation of input.degradations) {
+      this.reportDegradation(degradation);
+    }
+    if (!EXECUTION_LEVELS.includes(input.profile.executionLevel)) {
+      throw new Error("Runtime execution level is invalid");
+    }
+    this.profile = input.profile;
+    this.provider = input.provider;
+    this.platform = input.platform;
+    this.workspace = input.workspace;
+    this.codeExecution = input.codeExecution;
+    this.sandbox = input.sandbox;
+    this.memoryProfile = input.memoryProfile;
+    this.memory = input.memory;
+    this.hostTools.push(...input.hostTools);
+    this.toolPolicy = input.toolPolicy;
+    for (const skill of input.skills) this.addSkill(skill);
+    for (const connector of input.connectors) this.addConnector(connector);
+    this.gateway = input.gateway;
+    for (const { name, extension } of input.extensions) {
+      this.addExtension(name, extension);
+    }
+    this.schedule = input.schedule;
+    for (const name of input.enabledSubagents) {
+      this.enabledSubagents.add(requiredName(name, "Subagent"));
+    }
+    this.subagents = input.subagents;
+    this.turnEvents = input.turnEvents;
+    this.commitGuards.push(...input.commitGuards);
+  }
+
+  private addSkill(skill: RuntimeSkillContribution): void {
+    const normalized = requiredName(skill.name, "Skill");
+    if (this.skillSources.has(normalized)) {
+      throw new Error(`Duplicate Runtime Skill: ${normalized}`);
+    }
+    const normalizedDescription = requiredName(
+      skill.description,
+      `Runtime Skill "${normalized}" description`,
+    );
+    const script = skill.script ?? {};
+    const network = script.network ?? "none";
+    if (network !== "none" && network !== "full") {
+      throw new Error(
+        `Runtime Skill "${normalized}" has invalid network permission`,
+      );
+    }
+    const workspace = script.workspace ?? "none";
+    if (
+      workspace !== "none" &&
+      workspace !== "read" &&
+      workspace !== "read-write"
+    ) {
+      throw new Error(
+        `Runtime Skill "${normalized}" has invalid workspace permission`,
+      );
+    }
+    const tools = [
+      ...new Set(
+        (script.tools ?? []).map((tool) =>
+          requiredName(tool, `Runtime Skill "${normalized}" Tool`),
+        ),
+      ),
+    ];
+    this.skillSources.set(normalized, Object.freeze({
+      name: normalized,
+      description: normalizedDescription,
+      source: skill.source,
+      script: Object.freeze({
+        network,
+        workspace,
+        tools: Object.freeze(tools),
+      }),
+    }));
+  }
+
+  private addConnector(server: RuntimeMcpServer): void {
+    const name = requiredName(server.name, "Connector");
+    if (this.connectors.has(name)) {
+      throw new Error(`Duplicate Runtime Connector: ${name}`);
+    }
+    if (!server.url.trim()) {
+      throw new Error(`Runtime Connector "${name}" URL must not be empty`);
+    }
+    this.connectors.set(name, Object.freeze({
+      name,
+      url: server.url.trim(),
+    }));
+  }
+
+  private addExtension(
+    name: string,
+    extension: RuntimeExtensionConfig,
+  ): void {
+    const normalized = requiredName(name, "Extension");
+    if (this.extensions.has(normalized)) {
+      throw new Error(`Duplicate Runtime Extension: ${normalized}`);
+    }
+    if (extension.manifest.name !== normalized) {
+      throw new Error(
+        `Runtime Extension name mismatch: expected "${normalized}", got "${extension.manifest.name}"`,
+      );
+    }
+    this.extensions.set(normalized, extension);
+  }
+
+  private reportDegradation(degradation: RuntimeDegradation): void {
+    this.degradations.push(Object.freeze({ ...degradation }));
+  }
+
+// #endregion
+
+// #region RuntimeBuilder 校验与候选生成
+
+  // 作用：校验全部声明，并生成一个不可变候选 Runtime。
+  // 调用：扁平 Assembly Input 合并完成后调用一次。
+  // 原因：所有交叉约束都在这里通过后才返回候选，旧 Snapshot 不会半更新。
+  async build(): Promise<RuntimeCandidate> {
+    if (!this.profile) {
+      throw new Error("Runtime assembly did not configure a profile");
+    }
+    if (!this.platform) {
+      throw new Error("Runtime assembly did not bind a platform");
+    }
+    if (!this.provider) {
+      throw new Error("Runtime assembly did not bind a provider");
+    }
+    if (!this.profile.model.trim()) {
+      throw new Error("Runtime model must not be empty");
+    }
+    if (
+      !this.provider.defaultModel.trim() ||
+      this.provider.endpoints.length === 0 ||
+      !this.provider.endpoints.some((endpoint) =>
+        endpoint.models.includes(this.provider!.defaultModel)
+      ) ||
+      this.provider.endpoints.some((endpoint) =>
+        !endpoint.apiKey.trim() ||
+        !endpoint.baseURL.trim() ||
+        endpoint.models.length === 0
+      )
+    ) {
+      throw new Error("No usable Provider credential is configured");
+    }
+    if (!this.platform.loader) {
+      throw new Error("Runtime platform loader is required");
+    }
+    if (typeof this.platform.outbound !== "function") {
+      throw new Error("Runtime platform outbound port is required");
+    }
+
+    assertMemoryProfile(this.memoryProfile);
+    if (this.memoryProfile.enabled && (!this.workspace || !this.memory)) {
+      throw new Error(
+        "Enabled Runtime memory requires Workspace and Memory bindings",
+      );
+    }
+    const profile = freezeRuntimeProfile({
+      model: this.profile.model.trim(),
+      thinking: this.profile.thinking,
+      systemPrompt: this.profile.systemPrompt,
+      denyPolicy: this.toolPolicy?.denyPolicy,
+      enabledSubagents: [...this.enabledSubagents],
+      mcpServers: [...this.connectors.values()],
+      executionLevel: this.profile.executionLevel,
+      memory: this.memoryProfile,
+    });
+    const provider: RuntimeProviderPort = Object.freeze({
+      defaultModel: this.provider.defaultModel,
+      endpoints: Object.freeze(this.provider.endpoints.map(
+        (endpoint) => Object.freeze({
+          ...endpoint,
+          ...(endpoint.headers
+            ? { headers: Object.freeze({ ...endpoint.headers }) }
+            : {}),
+          models: Object.freeze([...endpoint.models]),
+        }),
+      )),
+    });
+    const endpoints = provider.endpoints.filter((endpoint) =>
+      endpoint.models.includes(profile.model)
+    );
+    if (endpoints.length !== 1) {
+      throw new Error(
+        endpoints.length === 0
+          ? `Model is not configured by this deployment: ${profile.model}`
+          : `Model is configured by multiple endpoints: ${profile.model}`,
+      );
+    }
+    const resolvedModel = resolvePiModel(provider, profile.model);
+    const endpoint = endpoints[0]!;
+    const webSearch = createWebSearch({
+      endpoint,
+      model: profile.model,
+      maxTokens: resolvedModel.maxTokens,
+      reasoning: resolvedModel.reasoning,
+    });
+    const skillSources = [...this.skillSources.values()];
+    const toolSurface = await createToolSurface({
+      platform: this.platform,
+      ...(this.workspace ? { workspace: this.workspace } : {}),
+      ...(this.memoryProfile.enabled && this.memory
+        ? { memory: { port: this.memory, profile: this.memoryProfile } }
+        : {}),
+      hostTools: this.hostTools,
+      skills: skillSources,
+      enabledSubagents: [...this.enabledSubagents],
+      webSearch,
+      extensions: [...this.extensions.values()],
+      ...(this.toolPolicy ? { policy: this.toolPolicy } : {}),
+    });
+    for (const degradation of toolSurface.degradations) {
+      this.reportDegradation(degradation);
+    }
+    const bindings: RuntimeBindings = Object.freeze({
+      provider,
+      platform: Object.freeze({ ...this.platform }),
+      ...(this.gateway ? { gateway: this.gateway } : {}),
+      ...(this.workspace ? { workspace: this.workspace } : {}),
+      ...(this.memoryProfile.enabled && this.memory
+        ? { memory: this.memory }
+        : {}),
+      skills: Object.freeze({
+        sources: Object.freeze(skillSources),
+      }),
+      ...(this.turnEvents ? { turnEvents: this.turnEvents } : {}),
+    });
+    const snapshot: RuntimeSnapshot = Object.freeze({
+      profile,
+      bindings,
+      pi: createPiRuntimeAssembly({
+        profile,
+        provider,
+        toolSurface: toolSurface.surface,
+        mcpServers: profile.mcpServers,
+        extensions: toolSurface.extensions,
+      }),
+      degradations: Object.freeze([
+        ...this.degradations,
+      ]),
+    });
+
+    return Object.freeze({
+      snapshot,
+      commitGuards: Object.freeze([
+        ...this.commitGuards,
+      ]),
+    });
+  }
+
+}
+
+/**
+ * 在不改动当前 Runtime 的前提下生成一个隔离候选。
+ *
+ * @remarks
+ * `AgentRuntimeKernel` 在初始化或重载时调用它。
+ *
+ * 任何合并、校验或 Tool Surface 构建失败都不会产生 commit。
+ *
+ * 该函数有意不从包入口导出，提交生命周期只能由 Kernel 控制。
+ *
+ * @internal
+ */
+export async function prepareRuntimeCandidate(
+  input: RuntimeAssemblyInput,
+): Promise<RuntimeCandidate> {
+  const builder = new RuntimeBuilder();
+  builder.merge(input);
+  return builder.build();
+}
+
+/**
+ * 完成候选装配、提交前检查，并在最后一步安装 Snapshot。
+ *
+ * @remarks
+ * `AgentRuntimeKernel.initConfig` 在首次加载或显式重载时调用它。
+ *
+ * `commit` 只在全部准备、合并、校验和 guard 成功后调用一次。
+ *
+ * @internal
+ */
+export async function assembleRuntime(
+  input: RuntimeAssemblyInput,
+  commit: (snapshot: RuntimeSnapshot) => void,
+): Promise<void> {
+  const candidate = await prepareRuntimeCandidate(input);
+  for (const guard of candidate.commitGuards) {
+    await guard();
+  }
+  commit(candidate.snapshot);
+}
+
+export function toolRegistryPiToolCandidates(
+  registry: ToolRegistry,
+  settings?: Pick<RuntimeSettings, "toolPolicy">,
+): PiToolCandidate[] {
+  const deny = new Set(settings?.toolPolicy?.denyPolicy?.deny ?? []);
+  const allowsTool = settings?.toolPolicy?.allowsTool;
+  const candidates: PiToolCandidate[] = [];
+  for (const [name, spec] of Object.entries(registry)) {
+    if (deny.has(name)) continue;
+    if (allowsTool?.(name) === false) continue;
+    const normalized = requiredName(name, "Platform Tool");
+    candidates.push(Object.freeze({
+      owner: "platform",
+      requiredExecutionLevel: spec.requiredExecutionLevel,
+      ...(spec.alwaysRequiresApproval
+        ? { alwaysRequiresApproval: true }
+        : {}),
+      tool: Object.freeze({
+        name: normalized,
+        label: spec.label,
+        description: spec.description,
+        parameters: spec.parameters,
+        async execute(
+          toolCallId: string,
+          input: unknown,
+          signal?: AbortSignal,
+        ) {
+          const result = await spec.execute(input, {
+            toolCallId,
+            signal: signal ?? new AbortController().signal,
+          });
+          if (
+            result != null &&
+            typeof result === "object" &&
+            "content" in result &&
+            Array.isArray((result as { content?: unknown }).content)
+          ) {
+            return result as import("@earendil-works/pi-agent-core").AgentToolResult<unknown>;
+          }
+          let text: string;
+          try {
+            text = JSON.stringify(result) ?? String(result);
+          } catch {
+            text = String(result);
+          }
+          return {
+            content: [{ type: "text" as const, text }],
+            details: result,
+          };
+        },
+      } as AgentTool<any, any>),
+    }));
+  }
+  return candidates;
+}
+
+function hooksToTurnEventsPort<
+  Env extends Cloudflare.Env,
+  Config,
+  Command,
+  Change,
+>(
+  ctx: AssembleRuntimeSnapshotInput<Env, Config, Command, Change>["ctx"],
+  hooks?: RuntimeAgentHooks<Env, Config, Command, Change>,
+): RuntimeTurnEventsPort | undefined {
+  if (!hooks) return undefined;
+  if (
+    !hooks.onTurnEnd &&
+    !hooks.onModelUsage &&
+    !hooks.onToolStart &&
+    !hooks.onToolSettled &&
+    !hooks.onApproval &&
+    !hooks.onActivityChanged &&
+    !hooks.onSubmissionTerminal
+  ) {
+    return undefined;
+  }
+  return {
+    onResponse: hooks.onTurnEnd
+      ? (messages) => hooks.onTurnEnd!(ctx, messages)
+      : async () => undefined,
+    ...(hooks.onModelUsage ? { onModelUsage: hooks.onModelUsage } : {}),
+    ...(hooks.onToolStart ? { onToolStart: hooks.onToolStart } : {}),
+    ...(hooks.onToolSettled ? { onToolSettled: hooks.onToolSettled } : {}),
+    ...(hooks.onApproval ? { onApproval: hooks.onApproval } : {}),
+    ...(hooks.onActivityChanged
+      ? { onActivityChanged: hooks.onActivityChanged }
+      : {}),
+    ...(hooks.onSubmissionTerminal
+      ? { onSubmissionTerminal: hooks.onSubmissionTerminal }
+      : {}),
+  };
+}
+
+/**
+ * 从 Config、Tool 和已加载 Resource 装配 Runtime 候选 Snapshot。
+ *
+ * @internal
+ */
+export async function assembleRuntimeSnapshot<
+  Env extends Cloudflare.Env,
+  Config,
+  Command = never,
+  Change = never,
+>(
+  input: AssembleRuntimeSnapshotInput<Env, Config, Command, Change>,
+): Promise<RuntimeCandidate> {
+  const resources = input.resources;
+  const toolAssembly = input.tools;
+  const settings = resources.settings;
+  const provider = resources.provider;
+  let profile = settings.profile;
+  if (input.hooks?.profileOverrides) {
+    const overrides = await withRuntimeLoadTimeout(
+      "profile-overrides",
+      () => input.hooks!.profileOverrides!(
+        input.ctx,
+        input.config,
+      ),
+    );
+    if (overrides.systemPrompt !== undefined) {
+      profile = { ...profile, systemPrompt: overrides.systemPrompt };
+    }
+    if (overrides.executionLevel !== undefined) {
+      profile = { ...profile, executionLevel: overrides.executionLevel };
+    }
+  }
+
+  const hostTools = toolRegistryPiToolCandidates(
+    toolAssembly.tools,
+    settings,
+  );
+
+  const commitGuards: Array<() => Promise<void>> = [];
+  if (toolAssembly.commitGuard) commitGuards.push(toolAssembly.commitGuard);
+  if (input.hooks?.beforeCommit) {
+    for (const guard of input.hooks.beforeCommit) {
+      commitGuards.push(() => guard(input.ctx, input.config));
+    }
+  }
+
+  const platform: RuntimePlatformPort = input.hooks?.gateTool
+    ? Object.freeze({
+        ...resources.platform,
+        gateTool: (request: {
+          toolCallId: string;
+          toolName: string;
+          input: unknown;
+          requiredExecutionLevel: import("./lib/execution-level").ExecutionLevel;
+          signal: AbortSignal;
+        }) => input.hooks!.gateTool!(request),
+      })
+    : resources.platform;
+
+  const memoryProfile =
+    toolAssembly.memoryProfile ?? settings.memoryProfile;
+  const enabledSubagents =
+    toolAssembly.enabledSubagents ?? settings.enabledSubagents;
+  const turnEvents = hooksToTurnEventsPort(input.ctx, input.hooks);
+
+  const toolPolicy: RuntimeToolSurfacePolicy | undefined =
+    settings.toolPolicy || toolAssembly.surfacePolicy
+      ? {
+          ...(settings.toolPolicy?.denyPolicy
+            ? { denyPolicy: settings.toolPolicy.denyPolicy }
+            : {}),
+          ...(settings.toolPolicy?.allowsTool
+            ? { allowsTool: settings.toolPolicy.allowsTool }
+            : {}),
+          ...(settings.toolPolicy?.allowsExtension
+            ? { allowsExtension: settings.toolPolicy.allowsExtension }
+            : {}),
+          ...(toolAssembly.surfacePolicy?.allowsTool
+            ? { allowsTool: toolAssembly.surfacePolicy.allowsTool }
+            : {}),
+          ...(toolAssembly.surfacePolicy?.allowsExtension
+            ? { allowsExtension: toolAssembly.surfacePolicy.allowsExtension }
+            : {}),
+        }
+      : undefined;
+
+  const assemblyInput: RuntimeAssemblyInput = {
+    profile,
+    memoryProfile,
+    ...(toolPolicy ? { toolPolicy } : {}),
+    enabledSubagents: [...enabledSubagents],
+    provider,
+    platform,
+    ...(toolAssembly.bindings?.workspace
+      ? { workspace: toolAssembly.bindings.workspace }
+      : {}),
+    ...(memoryProfile.enabled && toolAssembly.bindings?.memory
+      ? { memory: toolAssembly.bindings.memory }
+      : {}),
+    hostTools,
+    skills: resources.skills,
+    connectors: resources.connectors.servers,
+    ...(resources.connectors.gateway
+      ? { gateway: resources.connectors.gateway }
+      : {}),
+    extensions: resources.extensions,
+    ...(turnEvents ? { turnEvents } : {}),
+    commitGuards: [],
+    degradations: [
+      ...(toolAssembly.degradations ?? []),
+      ...(resources.degradations ?? []),
+      ...resources.connectors.degradations,
+    ],
+  };
+
+  const candidate = await prepareRuntimeCandidate(assemblyInput);
+  return Object.freeze({
+    snapshot: candidate.snapshot,
+    commitGuards: Object.freeze([
+      ...candidate.commitGuards,
+      ...commitGuards,
+    ]),
+    ...(input.hooks
+      ? {
+          hooks: input.hooks as unknown as RuntimeAgentHooks<
+            Cloudflare.Env,
+            unknown,
+            never,
+            never
+          >,
+        }
+      : {}),
+    ...(turnEvents ? { turnEvents } : {}),
+  });
+}
+
+// #endregion