@theokit/agents 7.3.1 → 7.4.1

package/dist/index.js

@@ -76,10 +76,7 @@ import {
   toolRuntimeName,
   translateSdkEvent,
   unicodeNormalizer
-} from "./chunk-7ECCHM4N.js";
-import {
-  __name
-} from "./chunk-Z4QWC7IK.js";
+} from "./chunk-PHUNONZT.js";
 
 // src/index.ts
 import { Agent as AgentDoSdk } from "@theokit/sdk";
@@ -87,16 +84,13 @@ import { Agent as AgentDoSdk } from "@theokit/sdk";
 // src/capability/capability.ts
 import { isDeepStrictEqual } from "util";
 var CapabilityConflictError = class extends Error {
-  static {
-    __name(this, "CapabilityConflictError");
-  }
   name = "CapabilityConflictError";
   constructor(field, previous, next, capability) {
     super(
-      // NUNCA ecoa os valores: um draft montado a partir de arquivo de config pode carregar
-      // token de MCP, header de auth, credencial de memória. Reporta a FORMA, como a validação
-      // de fronteira das capabilities já faz.
-      `capability "${capability}": campo "${field}" j\xE1 declarado (${shapeOf(previous)}) e redeclarado com valor diferente (${shapeOf(next)}) \u2014 declare uma vez s\xF3.`
+      // NEVER echo the values: a draft assembled from a config file may carry an MCP token, an auth
+      // header, a memory credential. Report the SHAPE, as the capabilities' boundary validation
+      // already does.
+      `capability "${capability}": field "${field}" already declared (${shapeOf(previous)}) and redeclared with a different value (${shapeOf(next)}) \u2014 declare it once.`
     );
   }
 };
@@ -108,21 +102,14 @@ function shapeOf(value) {
   }
   return typeof value;
 }
-__name(shapeOf, "shapeOf");
 function createDraft() {
-  return {
-    tools: [],
-    agents: {},
-    provenance: []
-  };
+  return { tools: [], agents: {}, provenance: [] };
 }
-__name(createDraft, "createDraft");
 function applyCapabilities(capabilities, draft = createDraft()) {
   for (const c of capabilities) c.apply(draft);
   draft.stream ??= true;
   return draft;
 }
-__name(applyCapabilities, "applyCapabilities");
 function setOnce(draft, field, value, capability) {
   if (value === void 0) return;
   const previous = draft[field];
@@ -130,36 +117,26 @@ function setOnce(draft, field, value, capability) {
     throw new CapabilityConflictError(field, previous, value, capability);
   }
   draft[field] = value;
-  draft.provenance.push({
-    capability,
-    contributed: [
-      field
-    ]
-  });
+  draft.provenance.push({ capability, contributed: [field] });
 }
-__name(setOnce, "setOnce");
 
 // src/capability/capabilities.ts
 function describe(value) {
   if (value === null) return "null";
   return Array.isArray(value) ? "array" : typeof value;
 }
-__name(describe, "describe");
 var ModelCapability = class {
-  static {
-    __name(this, "ModelCapability");
-  }
-  id;
-  reasoningEffort;
-  name = "model";
   constructor(id, reasoningEffort) {
     this.id = id;
     this.reasoningEffort = reasoningEffort;
     if (typeof id !== "string") {
-      throw new ConfigurationError(`model: esperava string, recebi ${describe(id)}`);
+      throw new ConfigurationError(`model: expected a string, got ${describe(id)}`);
     }
-    if (id.trim().length === 0) throw new ConfigurationError("model: id n\xE3o pode ser vazio");
+    if (id.trim().length === 0) throw new ConfigurationError("model: id cannot be empty");
   }
+  id;
+  reasoningEffort;
+  name = "model";
   apply(draft) {
     setOnce(draft, "model", this.id, this.name);
     if (this.reasoningEffort !== void 0) {
@@ -168,9 +145,6 @@ var ModelCapability = class {
   }
 };
 var ToolsCapability = class {
-  static {
-    __name(this, "ToolsCapability");
-  }
   name = "tools";
   #tools;
   constructor(tools) {
@@ -178,42 +152,34 @@ var ToolsCapability = class {
   }
   apply(draft) {
     draft.tools.push(...this.#tools);
-    draft.provenance.push({
-      capability: this.name,
-      contributed: [
-        "tools"
-      ]
-    });
+    draft.provenance.push({ capability: this.name, contributed: ["tools"] });
   }
 };
 var SkillsCapability = class {
-  static {
-    __name(this, "SkillsCapability");
-  }
   name = "skills";
   #entries;
   constructor(entries) {
     if (!Array.isArray(entries)) {
-      throw new ConfigurationError(`skills: esperava array de nomes, recebi ${describe(entries)}`);
+      throw new ConfigurationError(`skills: expected an array of names, got ${describe(entries)}`);
     }
     for (const e of entries) {
       if (typeof e === "string") {
         if (e.trim().length === 0) {
-          throw new ConfigurationError("skills: nome vazio \u2014 use um nome de skill n\xE3o vazio");
+          throw new ConfigurationError("skills: empty name \u2014 use a non-empty skill name");
         }
         continue;
       }
       if (typeof e !== "object" || e === null || Array.isArray(e)) {
-        throw new ConfigurationError(`skills: entrada inv\xE1lida (${describe(e)}) \u2014 use um nome ou um skill inline`);
+        throw new ConfigurationError(
+          `skills: invalid entry (${describe(e)}) \u2014 use a name or an inline skill`
+        );
       }
-      for (const field of [
-        "name",
-        "description",
-        "instructions"
-      ]) {
+      for (const field of ["name", "description", "instructions"]) {
         const value = e[field];
         if (typeof value !== "string" || value.trim().length === 0) {
-          throw new ConfigurationError(`skills: skill inline sem \`${field}\` v\xE1lido (${describe(value)}) \u2014 name, description e instructions s\xE3o obrigat\xF3rios`);
+          throw new ConfigurationError(
+            `skills: inline skill without a valid \`${field}\` (${describe(value)}) \u2014 name, description and instructions are all required`
+          );
         }
       }
     }
@@ -232,40 +198,21 @@ var SkillsCapability = class {
       // and no reference array form can express it) — revisit when one can.
       ...previous,
       ...compiled.skills,
-      enabled: [
-        ...previous.enabled ?? [],
-        ...compiled.skills.enabled ?? []
-      ],
-      ...previous.inline !== void 0 || compiled.skills.inline !== void 0 ? {
-        inline: [
-          ...previous.inline ?? [],
-          ...compiled.skills.inline ?? []
-        ]
-      } : {}
+      enabled: [...previous.enabled ?? [], ...compiled.skills.enabled ?? []],
+      ...previous.inline !== void 0 || compiled.skills.inline !== void 0 ? { inline: [...previous.inline ?? [], ...compiled.skills.inline ?? []] } : {}
     };
-    draft.provenance.push({
-      capability: this.name,
-      contributed: [
-        "skills"
-      ]
-    });
+    draft.provenance.push({ capability: this.name, contributed: ["skills"] });
   }
 };
 
 // src/capability/registry.ts
 var UnknownCapabilityError = class extends Error {
-  static {
-    __name(this, "UnknownCapabilityError");
-  }
   name = "UnknownCapabilityError";
   constructor(requested, known) {
-    super(`capability "${requested}" n\xE3o registrada. Conhecidas: ${known.join(", ") || "(nenhuma)"}.`);
+    super(`capability "${requested}" is not registered. Known: ${known.join(", ") || "(none)"}.`);
   }
 };
 var CapabilityRegistry = class {
-  static {
-    __name(this, "CapabilityRegistry");
-  }
   #factories = /* @__PURE__ */ new Map();
   register(name, factory) {
     this.#factories.set(name, factory);
@@ -275,9 +222,7 @@ var CapabilityRegistry = class {
     return this.#factories.has(name);
   }
   names() {
-    return [
-      ...this.#factories.keys()
-    ];
+    return [...this.#factories.keys()];
   }
   resolve(name, arg) {
     const factory = this.#factories.get(name);
@@ -286,15 +231,12 @@ var CapabilityRegistry = class {
   }
 };
 var CapabilityPreset = class {
-  static {
-    __name(this, "CapabilityPreset");
-  }
-  name;
-  #members;
   constructor(name, members) {
     this.name = name;
     this.#members = members;
   }
+  name;
+  #members;
   apply(draft) {
     for (const member of this.#members) member.apply(draft);
   }
@@ -302,169 +244,120 @@ var CapabilityPreset = class {
 
 // src/capability/agent-capabilities.ts
 var FieldCapability = class {
-  static {
-    __name(this, "FieldCapability");
-  }
-  value;
   constructor(value) {
     this.value = value;
   }
+  value;
   apply(draft) {
     setOnce(draft, this.field, this.value, this.name);
   }
 };
 var MemoryCapability = class extends FieldCapability {
-  static {
-    __name(this, "MemoryCapability");
-  }
   name = "memory";
   field = "memory";
 };
 var ContextWindowCapability = class {
-  static {
-    __name(this, "ContextWindowCapability");
-  }
-  options;
-  name = "context-window";
   constructor(options) {
     this.options = options;
   }
+  options;
+  name = "context-window";
   apply(draft) {
     setOnce(draft, "context", compileContextWindow(this.options).context, this.name);
   }
 };
 var ProjectContextCapability = class extends FieldCapability {
-  static {
-    __name(this, "ProjectContextCapability");
-  }
   name = "project-context";
   field = "projectContext";
 };
 var McpServersCapability = class extends FieldCapability {
-  static {
-    __name(this, "McpServersCapability");
-  }
   name = "mcp";
   field = "mcpServers";
 };
 var GuardrailsCapability = class extends FieldCapability {
-  static {
-    __name(this, "GuardrailsCapability");
-  }
   name = "guardrails";
   field = "guardrails";
 };
 var CheckpointCapability = class {
-  static {
-    __name(this, "CheckpointCapability");
-  }
-  options;
-  name = "checkpoint";
   constructor(options) {
     this.options = options;
   }
+  options;
+  name = "checkpoint";
   apply(draft) {
     if (this.options !== void 0 && this.options.storage !== "filesystem") {
-      console.warn(`[THEO_AGENT_CHECKPOINT_STORAGE_METADATA_ONLY] checkpoint({ storage: '${this.options.storage ?? "memory"}' }) does NOT resume across requests \u2014 only 'filesystem' selects the SDK's durable conversation store. Use checkpoint({ storage: 'filesystem' }) for cross-request resume.`);
+      console.warn(
+        `[THEO_AGENT_CHECKPOINT_STORAGE_METADATA_ONLY] checkpoint({ storage: '${this.options.storage ?? "memory"}' }) does NOT resume across requests \u2014 only 'filesystem' selects the SDK's durable conversation store. Use checkpoint({ storage: 'filesystem' }) for cross-request resume.`
+      );
     }
     setOnce(draft, "checkpoint", this.options, this.name);
   }
 };
 var HumanInTheLoopCapability = class extends FieldCapability {
-  static {
-    __name(this, "HumanInTheLoopCapability");
-  }
   name = "human-in-the-loop";
   field = "hitl";
 };
 var SubAgentsCapability = class {
-  static {
-    __name(this, "SubAgentsCapability");
-  }
-  children;
-  name = "sub-agents";
   constructor(children) {
     this.children = children;
   }
+  children;
+  name = "sub-agents";
   apply(draft) {
     for (const [name, child] of Object.entries(this.children)) {
       if (name in draft.agents && draft.agents[name] !== child) {
-        throw new ConfigurationError(`sub-agents: filho "${name}" declarado duas vezes com defini\xE7\xF5es diferentes`);
+        throw new ConfigurationError(
+          `sub-agents: child "${name}" declared twice with different definitions`
+        );
       }
       draft.agents[name] = child;
     }
-    draft.provenance.push({
-      capability: this.name,
-      contributed: [
-        "agents"
-      ]
-    });
+    draft.provenance.push({ capability: this.name, contributed: ["agents"] });
   }
 };
 var SkillsOptionsCapability = class {
-  static {
-    __name(this, "SkillsOptionsCapability");
-  }
-  options;
-  name = "skills";
   constructor(options) {
     this.options = options;
   }
+  options;
+  name = "skills";
   apply(draft) {
     setOnce(draft, "skills", compileSkills(this.options), this.name);
   }
 };
 var SettingSourcesCapability = class extends FieldCapability {
-  static {
-    __name(this, "SettingSourcesCapability");
-  }
   name = "setting-sources";
   field = "settingSources";
 };
 var PluginsCapability = class extends FieldCapability {
-  static {
-    __name(this, "PluginsCapability");
-  }
   name = "plugins";
   field = "plugins";
 };
 var RunContextCapability = class extends FieldCapability {
-  static {
-    __name(this, "RunContextCapability");
-  }
   name = "run-context";
   field = "runContext";
 };
 var SkillsResolverCapability = class extends FieldCapability {
-  static {
-    __name(this, "SkillsResolverCapability");
-  }
   name = "skills-resolver";
   field = "skillsResolver";
 };
 var AgentConfigCapability = class {
-  static {
-    __name(this, "AgentConfigCapability");
-  }
-  config;
-  name = "agent-config";
   constructor(config) {
     this.config = config;
     if (typeof config !== "object" || config === null) {
-      throw new ConfigurationError("agent-config: esperava um objeto de configura\xE7\xE3o");
+      throw new ConfigurationError("agent-config: expected a configuration object");
     }
-    for (const field of [
-      "maxIterations",
-      "timeoutMs"
-    ]) {
+    for (const field of ["maxIterations", "timeoutMs"]) {
       const value = config[field];
       if (value !== void 0 && (!Number.isFinite(value) || value <= 0)) {
-        throw new ConfigurationError(`agent-config: \`${field}\` deve ser um n\xFAmero positivo`);
+        throw new ConfigurationError(`agent-config: \`${field}\` must be a positive number`);
       }
     }
   }
+  config;
+  name = "agent-config";
   apply(draft) {
-    const claimedByMainLoop = /* @__PURE__ */ __name((field) => draft.provenance.some((p) => p.capability === "main-loop" && p.contributed.includes(field)), "claimedByMainLoop");
+    const claimedByMainLoop = (field) => draft.provenance.some((p) => p.capability === "main-loop" && p.contributed.includes(field));
     if (!claimedByMainLoop("maxIterations")) {
       setOnce(draft, "maxIterations", this.config.maxIterations, this.name);
     }
@@ -479,14 +372,11 @@ var AgentConfigCapability = class {
   }
 };
 var MainLoopCapability = class {
-  static {
-    __name(this, "MainLoopCapability");
-  }
-  config;
-  name = "main-loop";
   constructor(config) {
     this.config = config;
   }
+  config;
+  name = "main-loop";
   apply(draft) {
     const contributed = [];
     if (this.config.maxIterations !== void 0) {
@@ -497,33 +387,31 @@ var MainLoopCapability = class {
       draft.timeoutMs = this.config.timeoutMs;
       contributed.push("timeoutMs");
     }
-    if (contributed.length > 0) draft.provenance.push({
-      capability: this.name,
-      contributed
-    });
+    if (contributed.length > 0) draft.provenance.push({ capability: this.name, contributed });
   }
 };
 
 // src/capability/toolbox.ts
 var ToolboxCapability = class {
-  static {
-    __name(this, "ToolboxCapability");
-  }
   name = "toolbox";
   #instance;
   #declarations;
   #namespace;
   constructor(instance, options = {}) {
     if (typeof instance !== "object" || instance === null) {
-      throw new ConfigurationError("toolbox: esperava uma inst\xE2ncia de toolbox");
+      throw new ConfigurationError("toolbox: expected a toolbox instance");
     }
     const declared = options.tools ?? instance.constructor.tools;
     if (declared === void 0 || declared.length === 0) {
-      throw new ConfigurationError(`toolbox: ${instance.constructor.name} n\xE3o declara tools \u2014 use \`static tools = [...]\` ou a op\xE7\xE3o \`tools\``);
+      throw new ConfigurationError(
+        `toolbox: ${instance.constructor.name} declares no tools \u2014 use \`static tools = [...]\` or the \`tools\` option`
+      );
     }
     for (const tool of declared) {
       if (typeof instance[tool.method] !== "function") {
-        throw new ConfigurationError(`toolbox: ${instance.constructor.name}.${tool.method} n\xE3o \xE9 um m\xE9todo (tool "${tool.name}")`);
+        throw new ConfigurationError(
+          `toolbox: ${instance.constructor.name}.${tool.method} is not a method (tool "${tool.name}")`
+        );
       }
     }
     this.#instance = instance;
@@ -532,15 +420,15 @@ var ToolboxCapability = class {
     for (const tool of declared) toolRuntimeName(this.#namespace, tool.name);
   }
   /**
-  * The single derivation of this toolbox (M55). Both compilers below consume THIS object, so the
-  * tool registry and the HITL gate map cannot disagree on a name — the property is structural, not
-  * a convention repeated in two loops. That repetition is precisely how the two drifted apart in
-  * #145: the tool became `ns_tool` while its gate stayed `ns.tool`, silently ungating it.
-  *
-  * Same technique the `opencode` harness uses for the analogous tool↔permission coupling, where
-  * `Permission.visibleTools` filters the tool record itself rather than keeping a parallel map
-  * ("so the two cannot drift" — `permission/index.ts`).
-  */
+   * The single derivation of this toolbox (M55). Both compilers below consume THIS object, so the
+   * tool registry and the HITL gate map cannot disagree on a name — the property is structural, not
+   * a convention repeated in two loops. That repetition is precisely how the two drifted apart in
+   * #145: the tool became `ns_tool` while its gate stayed `ns.tool`, silently ungating it.
+   *
+   * Same technique the `opencode` harness uses for the analogous tool↔permission coupling, where
+   * `Permission.visibleTools` filters the tool record itself rather than keeping a parallel map
+   * ("so the two cannot drift" — `permission/index.ts`).
+   */
   #walk() {
     return {
       // `constructor` is typed `Function` by lib.d.ts; here it is used purely as an IDENTITY key
@@ -555,117 +443,87 @@ var ToolboxCapability = class {
         approval: tool.approval,
         trace: tool.trace ?? false,
         audit: tool.audit ?? false,
-        ...tool.hitl !== void 0 ? {
-          hitl: tool.hitl
-        } : {}
+        ...tool.hitl !== void 0 ? { hitl: tool.hitl } : {}
       }))
     };
   }
   /**
-  * M56 — the public `compile()` is GONE. It had zero callers anywhere in the monorepo and was kept
-  * only because deleting a public method is breaking; that concession is exactly the dead surface
-  * M55 set out to remove, preserved inside the milestone that removed it. `apply()` is the one path.
-  */
+   * M56 — the public `compile()` is GONE. It had zero callers anywhere in the monorepo and was kept
+   * only because deleting a public method is breaking; that concession is exactly the dead surface
+   * M55 set out to remove, preserved inside the milestone that removed it. `apply()` is the one path.
+   */
   apply(draft) {
     const walk = this.#walk();
-    draft.tools.push(...compileTools([
-      walk
-    ], /* @__PURE__ */ new Map([
-      [
-        walk.class,
-        this.#instance
-      ]
-    ])));
-    draft.provenance.push({
-      capability: this.name,
-      contributed: [
-        "tools"
-      ]
-    });
-    const gates = compileHitlGates([
-      walk
-    ]);
+    draft.tools.push(...compileTools([walk], /* @__PURE__ */ new Map([[walk.class, this.#instance]])));
+    draft.provenance.push({ capability: this.name, contributed: ["tools"] });
+    const gates = compileHitlGates([walk]);
     if (gates.size === 0) return;
     draft.hitl ??= /* @__PURE__ */ new Map();
     for (const [key, options] of gates) draft.hitl.set(key, options);
-    draft.provenance.push({
-      capability: this.name,
-      contributed: [
-        "hitl"
-      ]
-    });
+    draft.provenance.push({ capability: this.name, contributed: ["hitl"] });
   }
 };
 
 // src/capability/toolset.ts
-var ToolsetError = class extends Error {
-  static {
-    __name(this, "ToolsetError");
-  }
-  code;
+import { TheokitAgentError } from "@theokit/sdk/errors";
+var ToolsetError = class extends TheokitAgentError {
   constructor(message, code) {
-    super(message), this.code = code;
-    this.name = "ToolsetError";
+    super(message);
+    this.code = code;
   }
+  code;
+  name = "ToolsetError";
 };
 var Toolset = class _Toolset {
-  static {
-    __name(this, "Toolset");
-  }
-  #porNome;
-  constructor(porNome) {
-    this.#porNome = porNome;
+  #byName;
+  constructor(byName) {
+    this.#byName = byName;
     Object.freeze(this);
   }
   /**
-  * Constrói a partir das tools já instanciadas. Falha alto em nome duplicado **na construção** — não
-  * na resolução: um descritor com duas tools de mesmo nome está errado no momento em que é escrito, e
-  * adiar o erro para o primeiro `resolve` esconde metade dos casos.
-  */
+   * Builds from tools that are already instantiated. Fails loud on a duplicate name **at construction**
+   * — not at resolution: a descriptor with two tools of the same name is wrong the moment it is
+   * written, and deferring the error to the first `resolve` hides half the cases.
+   */
   static from(tools) {
-    const porNome = /* @__PURE__ */ new Map();
+    const byName = /* @__PURE__ */ new Map();
     for (const tool of tools) {
-      if (porNome.has(tool.name)) {
+      if (byName.has(tool.name)) {
         throw new ToolsetError(`duplicate tool "${tool.name}" in toolset`, "duplicate_tool");
       }
-      porNome.set(tool.name, tool);
+      byName.set(tool.name, tool);
     }
-    return new _Toolset(porNome);
+    return new _Toolset(byName);
   }
-  /** Uma tool pelo nome. Lança com o nome no erro — nunca devolve `undefined` em silêncio. */
+  /** One tool by name. Throws with the name in the error — never returns `undefined` silently. */
   get(name) {
-    const tool = this.#porNome.get(name);
+    const tool = this.#byName.get(name);
     if (tool === void 0) {
       throw new ToolsetError(`unknown tool "${name}"`, "unknown_tool");
     }
     return tool;
   }
   /**
-  * Resolve uma whitelist. Falha alto em desconhecido **e** em duplicado dentro da própria lista:
-  * um time nunca concede em silêncio uma tool que o role não declarou, nem descarta em silêncio uma
-  * que declarou.
-  */
+   * Resolves a whitelist. Fails loud on an unknown name **and** on a duplicate within the list itself:
+   * a team never silently grants a tool the role did not declare, nor silently drops one it did.
+   */
   resolve(names) {
-    const vistos = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
     return names.map((name) => {
-      if (vistos.has(name)) {
+      if (seen.has(name)) {
         throw new ToolsetError(`duplicate tool "${name}" in a whitelist`, "duplicate_tool");
       }
-      vistos.add(name);
+      seen.add(name);
       return this.get(name);
     });
   }
-  /** Os nomes conhecidos, na ordem de registro. */
+  /** The known names, in registration order. */
   names() {
-    return [
-      ...this.#porNome.keys()
-    ];
+    return [...this.#byName.keys()];
   }
-  /** Todas as tools, na ordem de registro. */
+  /** All the tools, in registration order. */
   all() {
-    return [
-      ...this.#porNome.values()
-    ];
+    return [...this.#byName.values()];
   }
 };
 
@@ -673,7 +531,6 @@ var Toolset = class _Toolset {
 function trimTrailingSlash(url) {
   return url.endsWith("/") ? url.slice(0, -1) : url;
 }
-__name(trimTrailingSlash, "trimTrailingSlash");
 function buildAgentCard(entry, options) {
   const base = trimTrailingSlash(options.baseUrl);
   return {
@@ -686,24 +543,14 @@ function buildAgentCard(entry, options) {
       pushNotifications: false,
       stateTransitionHistory: false
     },
-    defaultInputModes: [
-      "text"
-    ],
-    defaultOutputModes: [
-      "text"
-    ],
-    skills: entry.tools.map((t) => ({
-      id: t.name,
-      name: t.name,
-      description: t.description
-    }))
+    defaultInputModes: ["text"],
+    defaultOutputModes: ["text"],
+    skills: entry.tools.map((t) => ({ id: t.name, name: t.name, description: t.description }))
   };
 }
-__name(buildAgentCard, "buildAgentCard");
 function wellKnownCardPath(agentName) {
   return `/.well-known/${agentName}/agent-card.json`;
 }
-__name(wellKnownCardPath, "wellKnownCardPath");
 
 // src/a2a/mcp-server-manifest.ts
 var MCP_PROTOCOL_VERSION = "2024-11-05";
@@ -711,33 +558,20 @@ function buildMcpToolDescriptors(entry) {
   return entry.tools.map((t) => ({
     name: t.name,
     description: t.description,
-    inputSchema: {
-      type: "object",
-      properties: {}
-    }
+    inputSchema: { type: "object", properties: {} }
   }));
 }
-__name(buildMcpToolDescriptors, "buildMcpToolDescriptors");
 function mcpServerInfo(entry) {
-  return {
-    name: entry.name,
-    version: "1.0",
-    protocolVersion: MCP_PROTOCOL_VERSION
-  };
+  return { name: entry.name, version: "1.0", protocolVersion: MCP_PROTOCOL_VERSION };
 }
-__name(mcpServerInfo, "mcpServerInfo");
 
 // src/a2a/a2a-client.ts
 function buildHeaders(config) {
-  const headers = {
-    "content-type": "application/json",
-    ...config.headers
-  };
+  const headers = { "content-type": "application/json", ...config.headers };
   if (config.auth?.bearer) headers.authorization = `Bearer ${config.auth.bearer}`;
   if (config.auth?.apiKey) headers[config.auth.apiKey.header] = config.auth.apiKey.value;
   return headers;
 }
-__name(buildHeaders, "buildHeaders");
 function createA2ATool(config) {
   const doFetch = config.fetchImpl ?? fetch;
   return {
@@ -745,34 +579,24 @@ function createA2ATool(config) {
     description: config.description,
     inputSchema: {
       type: "object",
-      properties: {
-        message: {
-          type: "string",
-          description: "The message to send to the remote agent."
-        }
-      },
-      required: [
-        "message"
-      ]
+      properties: { message: { type: "string", description: "The message to send to the remote agent." } },
+      required: ["message"]
     },
-    handler: /* @__PURE__ */ __name(async (input) => {
+    handler: async (input) => {
       const message = typeof input.message === "string" ? input.message : "";
       const res = await doFetch(config.url, {
         method: "POST",
         headers: buildHeaders(config),
-        body: JSON.stringify({
-          message
-        })
+        body: JSON.stringify({ message })
       });
       if (!res.ok) {
         throw new Error(`A2A call to "${config.name}" failed: ${res.status} ${res.statusText}`);
       }
       const data = await res.json();
       return data.response ?? data.text ?? "";
-    }, "handler")
+    }
   };
 }
-__name(createA2ATool, "createA2ATool");
 
 // src/conversation-scope.ts
 var SEPARATOR = "/";
@@ -781,19 +605,14 @@ function deriveConversationId(resource, thread) {
   if (!thread) throw new Error("[@theokit/agents] deriveConversationId: thread must be non-empty");
   return `${encodeURIComponent(resource)}${SEPARATOR}${encodeURIComponent(thread)}`;
 }
-__name(deriveConversationId, "deriveConversationId");
 function parseConversationId(id) {
   const idx = id.indexOf(SEPARATOR);
   if (idx <= 0 || idx >= id.length - 1) return null;
   const resource = decodeURIComponent(id.slice(0, idx));
   const thread = decodeURIComponent(id.slice(idx + 1));
   if (!resource || !thread) return null;
-  return {
-    resource,
-    thread
-  };
+  return { resource, thread };
 }
-__name(parseConversationId, "parseConversationId");
 
 // src/skills-resolver.ts
 async function resolveEnabledSkills(selection, ctx) {
@@ -809,22 +628,15 @@ async function resolveEnabledSkills(selection, ctx) {
   if (!names.every((n) => typeof n === "string" && n.trim().length > 0)) {
     throw new Error("[@theokit/agents] skills resolver must return non-empty skill NAME strings");
   }
-  return [
-    ...names
-  ];
+  return [...names];
 }
-__name(resolveEnabledSkills, "resolveEnabledSkills");
 
 // src/acp/protocol.ts
 function encodeAcpMessage(message) {
   return `${JSON.stringify(message)}
 `;
 }
-__name(encodeAcpMessage, "encodeAcpMessage");
 var AcpMessageDecoder = class {
-  static {
-    __name(this, "AcpMessageDecoder");
-  }
   buffer = "";
   /** Feed a chunk; returns the messages completed by this chunk (possibly empty). */
   push(chunk) {
@@ -838,9 +650,7 @@ var AcpMessageDecoder = class {
         try {
           messages.push(JSON.parse(line));
         } catch (cause) {
-          throw new Error(`[@theokit/agents] ACP decode failed on line: ${line}`, {
-            cause
-          });
+          throw new Error(`[@theokit/agents] ACP decode failed on line: ${line}`, { cause });
         }
       }
       newlineIndex = this.buffer.indexOf("\n");
@@ -853,20 +663,10 @@ var AcpMessageDecoder = class {
 function isResponse(m) {
   return typeof m.id === "number" && ("result" in m || "error" in m) && !("method" in m);
 }
-__name(isResponse, "isResponse");
 function isServerRequest(m) {
   return typeof m.method === "string" && typeof m.id === "number";
 }
-__name(isServerRequest, "isServerRequest");
 var AcpClient = class {
-  static {
-    __name(this, "AcpClient");
-  }
-  transport;
-  nextId = 1;
-  pending = /* @__PURE__ */ new Map();
-  handlers = /* @__PURE__ */ new Map();
-  decoder = new AcpMessageDecoder();
   constructor(transport) {
     this.transport = transport;
     transport.subscribe((chunk) => {
@@ -875,20 +675,17 @@ var AcpClient = class {
       }
     });
   }
+  transport;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  decoder = new AcpMessageDecoder();
   /** Send a JSON-RPC request and resolve with its `result` (or reject on `error`). */
   request(method, params) {
     const id = this.nextId++;
     return new Promise((resolve, reject) => {
-      this.pending.set(id, {
-        resolve,
-        reject
-      });
-      this.transport.send(encodeAcpMessage({
-        jsonrpc: "2.0",
-        id,
-        method,
-        params
-      }));
+      this.pending.set(id, { resolve, reject });
+      this.transport.send(encodeAcpMessage({ jsonrpc: "2.0", id, method, params }));
     });
   }
   /** Register a handler for a server→client request method (e.g. `session/request_permission`). */
@@ -911,32 +708,22 @@ var AcpClient = class {
   async handleServerRequest(req) {
     const handler = this.handlers.get(req.method);
     if (!handler) {
-      this.transport.send(encodeAcpMessage({
-        jsonrpc: "2.0",
-        id: req.id,
-        error: {
-          code: -32601,
-          message: `No handler: ${req.method}`
-        }
-      }));
+      this.transport.send(
+        encodeAcpMessage({ jsonrpc: "2.0", id: req.id, error: { code: -32601, message: `No handler: ${req.method}` } })
+      );
       return;
     }
     try {
       const result = await handler(req.params);
-      this.transport.send(encodeAcpMessage({
-        jsonrpc: "2.0",
-        id: req.id,
-        result
-      }));
+      this.transport.send(encodeAcpMessage({ jsonrpc: "2.0", id: req.id, result }));
     } catch (err) {
-      this.transport.send(encodeAcpMessage({
-        jsonrpc: "2.0",
-        id: req.id,
-        error: {
-          code: -32603,
-          message: err instanceof Error ? err.message : "handler failed"
-        }
-      }));
+      this.transport.send(
+        encodeAcpMessage({
+          jsonrpc: "2.0",
+          id: req.id,
+          error: { code: -32603, message: err instanceof Error ? err.message : "handler failed" }
+        })
+      );
     }
   }
 };
@@ -946,7 +733,12 @@ import { Squad, Tool, Provider } from "@theokit/sdk";
 import { setDiagnosticsSink } from "@theokit/sdk";
 import { SubAgent } from "@theokit/sdk/a2a";
 import { assertNoSymlinkEscape, isForbiddenPath, safePathJoin } from "@theokit/sdk/path-safety";
-import { CONTEXT_WINDOW_FLOOR, CONTEXT_WINDOW_MARGIN, ContextWindowMarginError, resolveEffectiveContextWindow } from "@theokit/sdk/compaction";
+import {
+  CONTEXT_WINDOW_FLOOR,
+  CONTEXT_WINDOW_MARGIN,
+  ContextWindowMarginError,
+  resolveEffectiveContextWindow
+} from "@theokit/sdk/compaction";
 export * from "@theokit/sdk/errors";
 export * from "@theokit/sdk/retry";
 export * from "@theokit/sdk/concurrency";
@@ -957,76 +749,51 @@ import { BudgetExceededError as BudgetExceededError2 } from "@theokit/sdk/errors
 
 // src/in-process-turn.ts
 var InProcessApprovalRequiredError = class extends Error {
-  static {
-    __name(this, "InProcessApprovalRequiredError");
-  }
   constructor(toolNames) {
-    super(`Agent has HITL-gated tool(s) [${toolNames.join(", ")}] but no \`awaitApproval\` resolver was supplied to streamAgentTurnInProcess. In-process runs must resolve approvals inline \u2014 pass awaitApproval, or remove the gate. Refused (fail-closed).`);
+    super(
+      `Agent has HITL-gated tool(s) [${toolNames.join(", ")}] but no \`awaitApproval\` resolver was supplied to streamAgentTurnInProcess. In-process runs must resolve approvals inline \u2014 pass awaitApproval, or remove the gate. Refused (fail-closed).`
+    );
     this.name = "InProcessApprovalRequiredError";
   }
 };
-function resolvedorDaPostura(postura) {
-  if (postura === void 0) return void 0;
-  switch (postura.kind) {
+function postureResolver(posturePolicy) {
+  if (posturePolicy === void 0) return void 0;
+  switch (posturePolicy.kind) {
     case "interactive":
-      return postura.awaitApproval;
+      return posturePolicy.awaitApproval;
     case "auto-approve":
-      return () => Promise.resolve({
-        approved: true,
-        reason: postura.reason
-      });
+      return () => Promise.resolve({ approved: true, reason: posturePolicy.reason });
     case "auto-reject":
-      return () => Promise.resolve({
-        approved: false,
-        reason: postura.reason
-      });
+      return () => Promise.resolve({ approved: false, reason: posturePolicy.reason });
     case "owned-by-surface":
       return void 0;
   }
 }
-__name(resolvedorDaPostura, "resolvedorDaPostura");
-function streamAgentTurnInProcess(mod, apiKey, input, deps = {
-  stream: streamAgentUIMessages
-}) {
+function streamAgentTurnInProcess(mod, apiKey, input, deps = { stream: streamAgentUIMessages }) {
   const compiled = compileAgentModule(mod, input.source);
   const gated = compiled.hitl;
   if (gated && gated.size > 0 && !input.awaitApproval && input.approvals === void 0) {
-    throw new InProcessApprovalRequiredError([
-      ...gated.keys()
-    ]);
+    throw new InProcessApprovalRequiredError([...gated.keys()]);
   }
   const resolve = input.awaitApproval;
-  const resolverDeAprovacao = resolve ? (approvalId, opts, toolName) => resolve({
-    approvalId,
-    toolName,
-    opts
-  }) : resolvedorDaPostura(input.approvals);
-  const hitl = gated && gated.size > 0 && resolverDeAprovacao ? {
-    gated,
-    awaitApproval: resolverDeAprovacao
-  } : void 0;
+  const approvalResolver = resolve ? (approvalId, opts, toolName) => resolve({ approvalId, toolName, opts }) : postureResolver(input.approvals);
+  const hitl = gated && gated.size > 0 && approvalResolver ? { gated, awaitApproval: approvalResolver } : void 0;
   const sessionId = input.sessionId ?? crypto.randomUUID();
   return (async function* () {
     if (compiled.skillsResolver) {
       const enabled = await resolveEnabledSkills(compiled.skillsResolver, compiled.runContext ?? {});
-      if (enabled !== void 0) compiled.skills = {
-        enabled,
-        autoInject: true
-      };
+      if (enabled !== void 0) compiled.skills = { enabled, autoInject: true };
     }
     yield* deps.stream(compiled, apiKey, {
       message: input.message,
       // M35 — pass images through so the SDK send uses the structured `{ text, images }` form.
-      ...input.images !== void 0 ? {
-        images: input.images
-      } : {},
+      ...input.images !== void 0 ? { images: input.images } : {},
       sessionId,
       hitl,
       signal: input.signal
     });
   })();
 }
-__name(streamAgentTurnInProcess, "streamAgentTurnInProcess");
 
 // src/index.ts
 var Agent = AgentDoSdk;