@theokit/sdk 2.24.0 → 2.26.0

package/dist/a2a/index.js

@@ -1550,7 +1550,8 @@ function stripSecretsFromOptions(options) {
     local: serializeLocal(options.local),
     cloud: serializeCloud(options.cloud),
     memory: serializeMemory(options.memory),
-    skills: serializeEnabledList(options.skills),
+    // SE22 — a SkillsResolver function isn't serializable; persist only the static form.
+    skills: serializeEnabledList(typeof options.skills === "function" ? void 0 : options.skills),
     // Code-`Plugin` objects are closures and cannot be persisted (like custom
     // tools); only the named-enable settings form is serialized.
     plugins: serializeEnabledList(asPluginsSettings(options.plugins)),
@@ -1880,6 +1881,7 @@ function serializeCloud2(cloud) {
   return result;
 }
 function serializeSkills(skills) {
+  if (typeof skills === "function") return void 0;
   if (skills?.enabled === void 0 || skills.enabled.length === 0) return void 0;
   return { enabled: [...skills.enabled] };
 }
@@ -3448,8 +3450,19 @@ var init_cloud_agent = __esm({
 function validateCloudToolParity(options) {
   if (options.cloud === void 0) return;
   rejectFunctionSystemPrompt(options);
+  rejectFunctionSkills(options);
+  rejectProcessors(options);
   rejectStdioMcpLocalPaths(options);
 }
+function rejectProcessors(options) {
+  const hasProcessors = (options.inputProcessors?.length ?? 0) > 0 || (options.outputProcessors?.length ?? 0) > 0;
+  if (hasProcessors) {
+    throw new ConfigurationError(
+      "Cloud agents can't run guardrail processors \u2014 a Processor carries function handlers that don't survive serialization to PaaS. Run processors on a local agent, or move the guardrail into a server-side gateway in front of TheoCloud.",
+      { code: "cloud_incompatible_function_resolver" }
+    );
+  }
+}
 function rejectFunctionSystemPrompt(options) {
   if (typeof options.systemPrompt === "function") {
     throw new ConfigurationError(
@@ -3458,6 +3471,14 @@ function rejectFunctionSystemPrompt(options) {
     );
   }
 }
+function rejectFunctionSkills(options) {
+  if (typeof options.skills === "function") {
+    throw new ConfigurationError(
+      "Cloud agents require skills as a static settings object. SkillsResolver functions can't run on PaaS \u2014 resolve to a SkillsSettings object before Agent.create() or move the dynamic logic into a hook rule.",
+      { code: "cloud_incompatible_function_resolver" }
+    );
+  }
+}
 function rejectStdioMcpLocalPaths(options) {
   if (options.mcpServers === void 0) return;
   for (const [name, config] of Object.entries(options.mcpServers)) {
@@ -5690,9 +5711,235 @@ var init_subagents_loader = __esm({
   }
 });
 
+// src/internal/runtime/skills/skill-frontmatter.ts
+function asString(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function toStringFields(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) out[k] = asString(v);
+  return out;
+}
+function parseSkillFrontmatter(raw, fallbackName) {
+  const fields = extractAndParseFrontmatter(raw, fallbackName);
+  const name = resolveName(fields, fallbackName);
+  ensureRequiredFields(fields, name);
+  return buildFrontmatter(fields, name);
+}
+function stripSkillFrontmatter(raw) {
+  const match = /^---\s*\n[\s\S]*?\n---\s*\n/.exec(raw);
+  return (match === null ? raw : raw.slice(match[0].length)).trim();
+}
+function extractAndParseFrontmatter(raw, fallbackName) {
+  const match = /^---\s*\n([\s\S]*?)\n---\s*\n/.exec(raw);
+  if (match === null) {
+    throw new ConfigurationError(`Skill ${fallbackName} is missing frontmatter`, {
+      code: "missing_frontmatter"
+    });
+  }
+  const frontmatter = match[1] ?? "";
+  try {
+    return toStringFields(parseSimpleYaml(frontmatter));
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new ConfigurationError(
+      `Skill ${fallbackName} has malformed YAML frontmatter: ${detail}`,
+      { code: "schema_invalid", cause }
+    );
+  }
+}
+function resolveName(fields, fallbackName) {
+  if (hasContent(fields.name)) return fields.name;
+  if (hasContent(fallbackName)) return fallbackName;
+  throw new ConfigurationError("Skill at unknown path is missing required field: name", {
+    code: "schema_invalid"
+  });
+}
+function ensureRequiredFields(fields, name) {
+  if (!hasContent(fields.description)) {
+    throw new ConfigurationError(`Skill ${name} is missing required field: description`, {
+      code: "schema_invalid"
+    });
+  }
+}
+function buildFrontmatter(fields, name) {
+  const description = fields.description;
+  if (description === void 0) {
+    throw new ConfigurationError(`Skill ${name} missing description`, { code: "schema_invalid" });
+  }
+  const result = { name, description };
+  if (hasContent(fields.category)) result.category = fields.category;
+  const deps = parseDependencies(fields.dependencies);
+  if (deps !== void 0) result.dependencies = deps;
+  return result;
+}
+function parseDependencies(raw) {
+  if (!hasContent(raw)) return void 0;
+  const deps = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  return deps.length > 0 ? deps : void 0;
+}
+function hasContent(value) {
+  return value !== void 0 && value.trim().length > 0;
+}
+var init_skill_frontmatter = __esm({
+  "src/internal/runtime/skills/skill-frontmatter.ts"() {
+    init_errors();
+    init_yaml_frontmatter();
+  }
+});
+async function discoverSkills(dir, options) {
+  let entries;
+  try {
+    entries = await readWorkspaceDir(dir, "skills_read_error", "skills directory");
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    let skillDir;
+    try {
+      skillDir = safePathJoin(dir, entry.name);
+      assertNoSymlinkEscape(skillDir, dir);
+    } catch {
+      continue;
+    }
+    const skillPath = join(skillDir, "SKILL.md");
+    let raw;
+    try {
+      raw = await readFile(skillPath, "utf8");
+    } catch {
+      continue;
+    }
+    const skill = tryParseSkill(raw, entry.name, skillPath, options);
+    if (skill !== void 0) skills.push(skill);
+  }
+  return skills;
+}
+function tryParseSkill(raw, fallbackName, source, options) {
+  try {
+    const frontmatter = parseSkillFrontmatter(raw, fallbackName);
+    const skill = {
+      name: frontmatter.name,
+      description: frontmatter.description,
+      source
+    };
+    if (frontmatter.category !== void 0) skill.category = frontmatter.category;
+    if (frontmatter.dependencies !== void 0) skill.dependencies = frontmatter.dependencies;
+    return skill;
+  } catch (cause) {
+    if (cause instanceof ConfigurationError) {
+      options?.onInvalidSkill?.({
+        name: fallbackName,
+        source,
+        code: cause.code ?? "unknown",
+        message: cause.message
+      });
+      return void 0;
+    }
+    throw cause;
+  }
+}
+var init_discover_skills = __esm({
+  "src/internal/runtime/skills/discover-skills.ts"() {
+    init_errors();
+    init_path_guard();
+    init_workspace_dir();
+    init_skill_frontmatter();
+  }
+});
+var SkillsManager;
+var init_skills_manager = __esm({
+  "src/internal/runtime/skills/skills-manager.ts"() {
+    init_discover_skills();
+    init_skill_frontmatter();
+    SkillsManager = class {
+      constructor(cwd, _enabled, settingSourcesIncludeProject, skillsDir, inline) {
+        this.cwd = cwd;
+        this.settingSourcesIncludeProject = settingSourcesIncludeProject;
+        this.skillsDir = skillsDir;
+        this.inline = inline;
+      }
+      cwd;
+      settingSourcesIncludeProject;
+      skillsDir;
+      inline;
+      skills = [];
+      async initialize() {
+        if (!this.settingSourcesIncludeProject) {
+          this.skills = this.mergeInline([]);
+          return;
+        }
+        await this.refresh();
+      }
+      async refresh() {
+        const skillsRoot = this.skillsDir ?? join(this.cwd, ".theokit", "skills");
+        const discovered = await discoverSkills(skillsRoot, {
+          onInvalidSkill: (info) => {
+            process.stderr.write(
+              `[theokit-sdk] skill ${info.name} skipped (${info.code}): ${info.message}
+`
+            );
+          }
+        });
+        this.skills = this.mergeInline(discovered);
+      }
+      /** M22 — merge inline skills over discovered ones; inline wins on a name conflict. */
+      mergeInline(discovered) {
+        if (this.inline === void 0 || this.inline.length === 0) return discovered;
+        const inlineNames = new Set(this.inline.map((s) => s.name));
+        return [...discovered.filter((s) => !inlineNames.has(s.name)), ...this.inline];
+      }
+      list() {
+        return Promise.resolve(this.skills);
+      }
+      /**
+       * SE20 — resolve a skill by name INCLUDING its body. Inline (`createSkill`)
+       * skills carry `instructions` on the object; filesystem skills read the body
+       * from their `source` SKILL.md (frontmatter stripped). `undefined` when no
+       * enabled skill matches (malformed skills were already excluded at discovery).
+       */
+      async get(name) {
+        const skill = this.skills.find((s) => s.name === name);
+        if (skill === void 0) return void 0;
+        const instructions = typeof skill.instructions === "string" ? skill.instructions : stripSkillFrontmatter(await readFile(skill.source, "utf8"));
+        const references = skill.references;
+        return {
+          name: skill.name,
+          description: skill.description,
+          instructions,
+          ...references !== void 0 ? { references } : {}
+        };
+      }
+    };
+  }
+});
+
 // src/internal/runtime/system-prompt/local-assembly.ts
-async function buildSystemPromptContext(inputs, userText, memoryFacts) {
-  const skills = inputs.skillsManager !== void 0 ? await inputs.skillsManager.list() : [];
+async function resolveSendSkills(inputs, userText, memoryFacts) {
+  const skills = inputs.options.skills;
+  if (typeof skills !== "function") {
+    return { manager: inputs.skillsManager, autoInject: skills?.autoInject ?? true };
+  }
+  const settings = await skills({
+    agentId: inputs.agentId,
+    cwd: inputs.workspaceCwd,
+    model: inputs.model,
+    userMessage: userText,
+    memory: memoryFacts.map((fact) => ({ text: fact.text }))
+  });
+  const manager = new SkillsManager(
+    inputs.workspaceCwd,
+    settings.enabled,
+    inputs.settingSourcesIncludeProject,
+    settings.skillsDir,
+    settings.inline
+  );
+  await manager.initialize();
+  return { manager, autoInject: settings.autoInject ?? true };
+}
+async function buildSystemPromptContext(inputs, userText, memoryFacts, manager = inputs.skillsManager) {
+  const skills = manager !== void 0 ? await manager.list() : [];
   return {
     agentId: inputs.agentId,
     cwd: inputs.workspaceCwd,
@@ -5703,10 +5950,11 @@ async function buildSystemPromptContext(inputs, userText, memoryFacts) {
   };
 }
 async function buildAssemblyContext(inputs, userText, baseSystemPrompt, memoryFacts, activeMemorySummary) {
-  const baseCtx = await buildSystemPromptContext(inputs, userText, memoryFacts);
+  const resolved = await resolveSendSkills(inputs, userText, memoryFacts);
+  const baseCtx = await buildSystemPromptContext(inputs, userText, memoryFacts, resolved.manager);
   const assemblyCtx = {
     ...baseCtx,
-    skillsAutoInject: inputs.options.skills?.autoInject ?? true,
+    skillsAutoInject: resolved.autoInject,
     memoryAutoInject: inputs.options.memory?.autoInject ?? true
   };
   if (baseSystemPrompt !== void 0) assemblyCtx.baseSystemPrompt = baseSystemPrompt;
@@ -5732,6 +5980,7 @@ async function assembleSystemPromptForSend(inputs, userText, baseSystemPrompt, m
 }
 var init_local_assembly = __esm({
   "src/internal/runtime/system-prompt/local-assembly.ts"() {
+    init_skills_manager();
   }
 });
 
@@ -7077,187 +7326,6 @@ var init_plugins_manager = __esm({
   }
 });
 
-// src/internal/runtime/skills/skill-frontmatter.ts
-function asString(v) {
-  return typeof v === "string" ? v : void 0;
-}
-function toStringFields(raw) {
-  const out = {};
-  for (const [k, v] of Object.entries(raw)) out[k] = asString(v);
-  return out;
-}
-function parseSkillFrontmatter(raw, fallbackName) {
-  const fields = extractAndParseFrontmatter(raw, fallbackName);
-  const name = resolveName(fields, fallbackName);
-  ensureRequiredFields(fields, name);
-  return buildFrontmatter(fields, name);
-}
-function extractAndParseFrontmatter(raw, fallbackName) {
-  const match = /^---\s*\n([\s\S]*?)\n---\s*\n/.exec(raw);
-  if (match === null) {
-    throw new ConfigurationError(`Skill ${fallbackName} is missing frontmatter`, {
-      code: "missing_frontmatter"
-    });
-  }
-  const frontmatter = match[1] ?? "";
-  try {
-    return toStringFields(parseSimpleYaml(frontmatter));
-  } catch (cause) {
-    const detail = cause instanceof Error ? cause.message : String(cause);
-    throw new ConfigurationError(
-      `Skill ${fallbackName} has malformed YAML frontmatter: ${detail}`,
-      { code: "schema_invalid", cause }
-    );
-  }
-}
-function resolveName(fields, fallbackName) {
-  if (hasContent(fields.name)) return fields.name;
-  if (hasContent(fallbackName)) return fallbackName;
-  throw new ConfigurationError("Skill at unknown path is missing required field: name", {
-    code: "schema_invalid"
-  });
-}
-function ensureRequiredFields(fields, name) {
-  if (!hasContent(fields.description)) {
-    throw new ConfigurationError(`Skill ${name} is missing required field: description`, {
-      code: "schema_invalid"
-    });
-  }
-}
-function buildFrontmatter(fields, name) {
-  const description = fields.description;
-  if (description === void 0) {
-    throw new ConfigurationError(`Skill ${name} missing description`, { code: "schema_invalid" });
-  }
-  const result = { name, description };
-  if (hasContent(fields.category)) result.category = fields.category;
-  const deps = parseDependencies(fields.dependencies);
-  if (deps !== void 0) result.dependencies = deps;
-  return result;
-}
-function parseDependencies(raw) {
-  if (!hasContent(raw)) return void 0;
-  const deps = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-  return deps.length > 0 ? deps : void 0;
-}
-function hasContent(value) {
-  return value !== void 0 && value.trim().length > 0;
-}
-var init_skill_frontmatter = __esm({
-  "src/internal/runtime/skills/skill-frontmatter.ts"() {
-    init_errors();
-    init_yaml_frontmatter();
-  }
-});
-async function discoverSkills(dir, options) {
-  let entries;
-  try {
-    entries = await readWorkspaceDir(dir, "skills_read_error", "skills directory");
-  } catch {
-    return [];
-  }
-  const skills = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    let skillDir;
-    try {
-      skillDir = safePathJoin(dir, entry.name);
-      assertNoSymlinkEscape(skillDir, dir);
-    } catch {
-      continue;
-    }
-    const skillPath = join(skillDir, "SKILL.md");
-    let raw;
-    try {
-      raw = await readFile(skillPath, "utf8");
-    } catch {
-      continue;
-    }
-    const skill = tryParseSkill(raw, entry.name, skillPath, options);
-    if (skill !== void 0) skills.push(skill);
-  }
-  return skills;
-}
-function tryParseSkill(raw, fallbackName, source, options) {
-  try {
-    const frontmatter = parseSkillFrontmatter(raw, fallbackName);
-    const skill = {
-      name: frontmatter.name,
-      description: frontmatter.description,
-      source
-    };
-    if (frontmatter.category !== void 0) skill.category = frontmatter.category;
-    if (frontmatter.dependencies !== void 0) skill.dependencies = frontmatter.dependencies;
-    return skill;
-  } catch (cause) {
-    if (cause instanceof ConfigurationError) {
-      options?.onInvalidSkill?.({
-        name: fallbackName,
-        source,
-        code: cause.code ?? "unknown",
-        message: cause.message
-      });
-      return void 0;
-    }
-    throw cause;
-  }
-}
-var init_discover_skills = __esm({
-  "src/internal/runtime/skills/discover-skills.ts"() {
-    init_errors();
-    init_path_guard();
-    init_workspace_dir();
-    init_skill_frontmatter();
-  }
-});
-var SkillsManager;
-var init_skills_manager = __esm({
-  "src/internal/runtime/skills/skills-manager.ts"() {
-    init_discover_skills();
-    SkillsManager = class {
-      constructor(cwd, _enabled, settingSourcesIncludeProject, skillsDir, inline) {
-        this.cwd = cwd;
-        this.settingSourcesIncludeProject = settingSourcesIncludeProject;
-        this.skillsDir = skillsDir;
-        this.inline = inline;
-      }
-      cwd;
-      settingSourcesIncludeProject;
-      skillsDir;
-      inline;
-      skills = [];
-      async initialize() {
-        if (!this.settingSourcesIncludeProject) {
-          this.skills = this.mergeInline([]);
-          return;
-        }
-        await this.refresh();
-      }
-      async refresh() {
-        const skillsRoot = this.skillsDir ?? join(this.cwd, ".theokit", "skills");
-        const discovered = await discoverSkills(skillsRoot, {
-          onInvalidSkill: (info) => {
-            process.stderr.write(
-              `[theokit-sdk] skill ${info.name} skipped (${info.code}): ${info.message}
-`
-            );
-          }
-        });
-        this.skills = this.mergeInline(discovered);
-      }
-      /** M22 — merge inline skills over discovered ones; inline wins on a name conflict. */
-      mergeInline(discovered) {
-        if (this.inline === void 0 || this.inline.length === 0) return discovered;
-        const inlineNames = new Set(this.inline.map((s) => s.name));
-        return [...discovered.filter((s) => !inlineNames.has(s.name)), ...this.inline];
-      }
-      list() {
-        return Promise.resolve(this.skills);
-      }
-    };
-  }
-});
-
 // src/internal/runtime/local-agent/local-agent-bootstrap.ts
 function registerLocalAgent(args) {
   registerAgent({
@@ -7293,16 +7361,23 @@ function bootstrapSubmanagers(args) {
     );
   }
   if (args.options.skills !== void 0 || args.settingSourcesIncludeProject) {
+    const staticSkills = typeof args.options.skills === "function" ? void 0 : args.options.skills;
     out.skillsManager = new SkillsManager(
       args.workspaceCwd,
-      args.options.skills?.enabled,
+      staticSkills?.enabled,
       args.settingSourcesIncludeProject,
       // M22 — custom skills directory + inline (code-defined) skills.
-      args.options.skills?.skillsDir,
-      args.options.skills?.inline
+      staticSkills?.skillsDir,
+      staticSkills?.inline
     );
     const localSkills = out.skillsManager;
-    out.skills = { list: () => localSkills.list() };
+    out.skills = {
+      // Project to the public shape (name + description only). Inline skills carry
+      // their body + references on the object; `list()` must never leak them —
+      // the body is reachable exclusively through `get()`.
+      list: async () => (await localSkills.list()).map((s) => ({ name: s.name, description: s.description })),
+      get: (name) => localSkills.get(name)
+    };
   }
   if (args.options.plugins !== void 0 || args.settingSourcesIncludePlugins) {
     out.pluginsManager = new PluginsManager(
@@ -16288,6 +16363,162 @@ var init_abort_utils = __esm({
   }
 });
 
+// src/internal/runtime/processors/run-processors.ts
+function fireViolation(processor, violation) {
+  try {
+    processor.onViolation?.(violation);
+  } catch {
+  }
+}
+function controlsFor(processor) {
+  return {
+    abort(reason) {
+      throw new ProcessorAbort(processor.id, reason);
+    },
+    warn(message, detail) {
+      fireViolation(processor, {
+        processorId: processor.id,
+        message,
+        ...detail !== void 0 ? { detail } : {}
+      });
+    }
+  };
+}
+function selectHandler(processor, phase) {
+  if (phase === "input") {
+    return processor.processInput ? { kind: "input", fn: processor.processInput } : void 0;
+  }
+  return processor.processOutput ? { kind: "output", fn: processor.processOutput } : void 0;
+}
+function invokeHandler(handler, value, agentId, controls) {
+  return handler.kind === "input" ? handler.fn({ message: value, agentId, ...controls }) : handler.fn({ text: value, agentId, ...controls });
+}
+async function runOneProcessor(processor, value, agentId, phase) {
+  const handler = selectHandler(processor, phase);
+  if (handler === void 0) return { value };
+  try {
+    const out = await invokeHandler(handler, value, agentId, controlsFor(processor));
+    return { value: typeof out === "string" ? out : value };
+  } catch (err) {
+    if (!(err instanceof ProcessorAbort)) throw err;
+    fireViolation(processor, { processorId: err.processorId, message: err.reason });
+    return { tripwire: { reason: err.reason, processorId: err.processorId } };
+  }
+}
+async function runPipeline(processors, initial, agentId, phase) {
+  let value = initial;
+  for (const processor of processors) {
+    const step = await runOneProcessor(processor, value, agentId, phase);
+    if ("tripwire" in step) return { kind: "tripwire", tripwire: step.tripwire };
+    value = step.value;
+  }
+  return { kind: "ok", value };
+}
+function runInputProcessors(processors, message, agentId) {
+  return runPipeline(processors, message, agentId, "input");
+}
+function runOutputProcessors(processors, text, agentId) {
+  return runPipeline(processors, text, agentId, "output");
+}
+var ProcessorAbort;
+var init_run_processors = __esm({
+  "src/internal/runtime/processors/run-processors.ts"() {
+    ProcessorAbort = class {
+      constructor(processorId, reason) {
+        this.processorId = processorId;
+        this.reason = reason;
+      }
+      processorId;
+      reason;
+    };
+  }
+});
+
+// src/internal/runtime/processors/tripwire-run.ts
+function emptyStream() {
+  return {
+    next: () => Promise.resolve({ done: true, value: void 0 }),
+    return: () => Promise.resolve({ done: true, value: void 0 }),
+    throw: (err) => Promise.reject(err),
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function createTripwireRun(args) {
+  const id = globalThis.crypto.randomUUID();
+  const result = {
+    id,
+    status: "cancelled",
+    tripwire: args.tripwire,
+    ...args.model !== void 0 ? { model: args.model } : {}
+  };
+  const run = {
+    id,
+    agentId: args.agentId,
+    status: "cancelled",
+    ...args.model !== void 0 ? { model: args.model } : {},
+    stream: () => emptyStream(),
+    wait: () => Promise.resolve(result),
+    cancel: () => Promise.resolve(),
+    conversation: () => Promise.resolve([]),
+    supports: (op) => SUPPORTED.has(op),
+    unsupportedReason: (op) => SUPPORTED.has(op) ? void 0 : `operation "${op}" is not available on a tripwire run`,
+    onDidChangeStatus: () => () => {
+    }
+    // already terminal — status never changes
+  };
+  registerRun(run);
+  return run;
+}
+var SUPPORTED;
+var init_tripwire_run = __esm({
+  "src/internal/runtime/processors/tripwire-run.ts"() {
+    init_run_registry();
+    SUPPORTED = /* @__PURE__ */ new Set([
+      "stream",
+      "wait",
+      "cancel",
+      "conversation"
+    ]);
+  }
+});
+
+// src/internal/runtime/processors/wrap-output-run.ts
+function wrapRunWithOutputProcessors(args) {
+  if (args.processors.length === 0) return args.run;
+  const compute = async () => {
+    const result = await args.run.wait();
+    if (result.status !== "finished" || result.result === void 0) return result;
+    const res = await runOutputProcessors(args.processors, result.result, args.agentId);
+    if (res.kind === "ok") return { ...result, result: res.value };
+    emitRunEvent(args.onRunEvent, {
+      type: "tripwire",
+      reason: res.tripwire.reason,
+      processorId: res.tripwire.processorId
+    });
+    const { result: _suppressed, ...metadata } = result;
+    return { ...metadata, status: "cancelled", tripwire: res.tripwire };
+  };
+  let processed;
+  const wrappedWait = () => {
+    processed ??= compute();
+    return processed;
+  };
+  return new Proxy(args.run, {
+    get(target, prop, receiver) {
+      if (prop === "wait") return wrappedWait;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+var init_wrap_output_run = __esm({
+  "src/internal/runtime/processors/wrap-output-run.ts"() {
+    init_run_events();
+    init_run_processors();
+  }
+});
+
 // src/internal/runtime/local-agent/local-agent-memory-hooks.ts
 async function applyPreUserSendHook(args) {
   const handlers = args.pluginManager.hooksFor("pre_user_send");
@@ -16340,11 +16571,38 @@ var init_local_agent_memory_hooks = __esm({
 });
 
 // src/internal/runtime/local-agent/local-agent-send.ts
+async function applyInputProcessors(inputs, message, rawUserText, options, sendModel) {
+  const processors = inputs.options.inputProcessors;
+  if (processors === void 0 || processors.length === 0) {
+    return { userText: rawUserText, effectiveMessage: message };
+  }
+  const res = await runInputProcessors(processors, rawUserText, inputs.agentId);
+  if (res.kind === "tripwire") {
+    emitRunEvent(options.onRunEvent, {
+      type: "tripwire",
+      reason: res.tripwire.reason,
+      processorId: res.tripwire.processorId
+    });
+    return {
+      tripwireRun: createTripwireRun({
+        agentId: inputs.agentId,
+        tripwire: res.tripwire,
+        model: sendModel
+      })
+    };
+  }
+  const effectiveMessage = typeof message === "string" ? res.value : { ...message, text: res.value };
+  return { userText: res.value, effectiveMessage };
+}
 async function executeSendLocked(inputs, message, options) {
   if (inputs.disposed) throw new AgentDisposedError(inputs.agentId);
   await consumePending(inputs.agentId, inputs.invalidationPending, inputs.clearInvalidation, inputs.reload);
-  inputs.applyModelOverride(normalizeModel(options.model));
-  const userText = typeof message === "string" ? message : message.text;
+  const sendModel = normalizeModel(options.model);
+  inputs.applyModelOverride(sendModel);
+  const rawUserText = typeof message === "string" ? message : message.text;
+  const gated = await applyInputProcessors(inputs, message, rawUserText, options, sendModel);
+  if ("tripwireRun" in gated) return gated.tripwireRun;
+  const { userText, effectiveMessage } = gated;
   if (inputs.options.onBeforeSend !== void 0) {
     await inputs.options.onBeforeSend({
       conversationId: inputs.agentId,
@@ -16356,7 +16614,7 @@ async function executeSendLocked(inputs, message, options) {
     pluginManager: inputs.pluginManagerCode,
     agentId: inputs.agentId,
     options: inputs.options,
-    original: message,
+    original: effectiveMessage,
     userText,
     sendOptions: options
   });
@@ -16394,11 +16652,18 @@ async function executeSendLocked(inputs, message, options) {
     memoryTools,
     effectiveMemoryProvider
   );
+  const outputProcessors = inputs.options.outputProcessors;
+  const processedRun = outputProcessors !== void 0 && outputProcessors.length > 0 ? wrapRunWithOutputProcessors({
+    run,
+    processors: outputProcessors,
+    agentId: inputs.agentId,
+    onRunEvent: options.onRunEvent
+  }) : run;
   return wrapRunWithPostReplyHook({
     pluginManager: inputs.pluginManagerCode,
     agentId: inputs.agentId,
     options: inputs.options,
-    run,
+    run: processedRun,
     userText
   });
 }
@@ -16409,10 +16674,14 @@ function readMemoryForSend(workspaceCwd, memoryConfig) {
 var init_local_agent_send = __esm({
   "src/internal/runtime/local-agent/local-agent-send.ts"() {
     init_errors();
+    init_run_events();
     init_abort_utils();
     init_memory_path_selector();
     init_memory_store();
     init_model_selection();
+    init_run_processors();
+    init_tripwire_run();
+    init_wrap_output_run();
     init_agent_session();
     init_safe_call();
     init_local_agent_invalidate();
@@ -17232,7 +17501,7 @@ var init_local_agent = __esm({
       }
       // biome-ignore format: G8 budget — thin accessor for the assembly inputs.
       assemblyInputs() {
-        return { agentId: this.agentId, workspaceCwd: this.workspaceCwd, model: this.model, options: this.options, context: this.context, skillsManager: this.skillsManager, systemPromptPipeline: this.systemPromptPipeline };
+        return { agentId: this.agentId, workspaceCwd: this.workspaceCwd, model: this.model, options: this.options, context: this.context, skillsManager: this.skillsManager, settingSourcesIncludeProject: this.settingSourcesIncludeProject, systemPromptPipeline: this.systemPromptPipeline };
       }
       async resolveSystemPrompt(userText, options, memoryFacts) {
         const base = await resolveSystemPromptForSend(