@theokit/agents 3.0.0 → 4.0.0

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-import { G as Guardrail, L as LoopStrategy, R as ReflectionStrategy, C as CompiledAgentOptions, M as MainLoopMeta, a as CompiledTool, b as ReasoningEffort, c as RoundStreamFactory, S as StreamEvent, D as DelegationResult, d as ContextWindowOptions, H as HumanInTheLoopOptions, e as McpServersMap, f as MemoryOptions, P as ProjectContextOptions, g as SkillsOptions, h as SkillsSelection, T as ToolOptions, A as ApprovalOptions, i as AgentManifestEntry } from './bridge-entry-8gsH0kVZ.js';
-export { j as AGENT_BRAND, k as AfterToolCallContext, l as AgentBuilder, m as AgentDefinition, n as AgentDefinitionError, o as AgentExecutionContext, p as AgentManifest, q as AgentManifestSource, r as AgentManifestTool, s as AgentOptions, t as AgentRoute, u as AgentRouteContext, v as AgentRunInfo, w as AgentStreamEvent, x as AgentTurnMetadata, y as AgentsPluginOptions, z as ApiErrorContext, B as ApiErrorDecision, E as ApiErrorPolicy, F as ApprovalRequiredEvent, I as ArtifactChunkEvent, J as ArtifactStartEvent, K as BackgroundDelegation, N as BeforeToolCallContext, O as BudgetExceededError, Q as BudgetOptions, U as CheckpointSavedEvent, V as CompiledContextWindow, W as ContextualTool, X as CostBudgetExceededError, Y as DEFAULT_MAX_ITERATIONS, Z as DefineAgentConfig, _ as DelegateFn, $ as DelegateOptions, a0 as DelegationError, a1 as DoneEvent, a2 as ErrorEvent, a3 as FileEditEvent, a4 as GuardrailAction, a5 as GuardrailPhase, a6 as GuardrailResult, a7 as GuardrailViolationError, a8 as HitlDecision, a9 as InferAgentInput, aa as InferAgentToolNames, ab as IterationEvent, ac as LLMCallContext, ad as LoopFinishReason, ae as LoopOutcome, af as LoopStrategyConfig, ag as MainLoopOptions, ah as McpApprovalSpec, ai as McpRegistryConfig, aj as McpRequestContext, ak as McpSelection, al as PartialToolCallEvent, am as PolicyHandler, an as ProcessInputContext, ao as ReflectionContext, ap as ReflectionResult, aq as ReflectionStrategyConfig, ar as RunStartedEvent, as as ScoreVerdict, at as ScoredDelegation, au as Scorer, av as SdkAgentHandle, aw as SdkMessage, ax as Segment, ay as SkillsRequestContext, az as StateUpdateEvent, aA as TextDeltaEvent, aB as ThinkingEvent, aC as TimeoutAction, aD as ToolCallEvent, aE as ToolCallVeto, aF as ToolHooks, aG as ToolHooksPlugin, aH as ToolResultEvent, aI as ToolWalkResult, aJ as ToolboxOptions, aK as ToolboxWalkResult, aL as agent, aM as agentsPlugin, aN as buildModelSelection, aO as compileAgentDefinition, aP as compileAgentModule, aQ as compileContextWindow, aR as compileProjectContext, aS as compileSkills, aT as compileTools, aU as contextualTool, aV as createAgentExecutionContext, aW as createApiErrorHandler, aX as createSdkAgentStream, aY as createThinkTagExtractor, aZ as createToolHooksPlugin, a_ as delegate, a$ as delegateBackground, b0 as delegateWithScoring, b1 as extractThinkTagStream, b2 as generateAgentManifest, b3 as generateAgentRoutes, b4 as isAgentContext, b5 as isAgentDefinition, b6 as isApprovalRequired, b7 as isDone, b8 as isError, b9 as isPartialToolCall, ba as isTextDelta, bb as isToolCall, bc as isToolResult, bd as ladderReflectionStrategy, be as loopStrategyConfigSchema, bf as mcpRegistry, bg as mcpToolApprovals, bh as noopReflectionStrategy, bi as presentUIMessageStream, bj as projectContextMetadataOnlyKnobs, bk as reflectionStrategyConfigSchema, bl as resolveEnabledSkills, bm as resolveLoopStrategy, bn as resolveMcpServers, bo as runWithApiErrorHandling, bp as streamAgentResponse, bq as streamAgentUIMessages, br as toAgentFactory, bs as translateSdkEvent } from './bridge-entry-8gsH0kVZ.js';
-import * as _theokit_sdk from '@theokit/sdk';
+import { G as Guardrail, L as LoopStrategy, R as ReflectionStrategy, C as CompiledAgentOptions, M as MainLoopMeta, a as CompiledTool, b as ReasoningEffort, c as RoundStreamFactory, S as StreamEvent, D as DelegationResult, d as ContextWindowOptions, e as SkillsOptions, T as ToolOptions, A as ApprovalOptions, H as HumanInTheLoopOptions, f as AgentManifestEntry } from './bridge-entry-Ddu3Ug_3.js';
+export { g as AGENT_BRAND, h as AfterToolCallContext, i as AgentBuilder, j as AgentDefinition, k as AgentDefinitionError, l as AgentExecutionContext, m as AgentManifest, n as AgentManifestSource, o as AgentManifestTool, p as AgentOptions, q as AgentRoute, r as AgentRouteContext, s as AgentRunInfo, t as AgentStreamEvent, u as AgentTurnMetadata, v as AgentsPluginOptions, w as ApiErrorContext, x as ApiErrorDecision, y as ApiErrorPolicy, z as ApprovalRequiredEvent, B as ArtifactChunkEvent, E as ArtifactStartEvent, F as BackgroundDelegation, I as BeforeToolCallContext, J as BudgetExceededError, K as BudgetOptions, N as CheckpointSavedEvent, O as CompiledContextWindow, P as ContextualTool, Q as CostBudgetExceededError, U as DEFAULT_MAX_ITERATIONS, V as DefineAgentConfig, W as DelegateFn, X as DelegateOptions, Y as DelegationError, Z as DoneEvent, _ as ErrorEvent, $ as FileEditEvent, a0 as GuardrailAction, a1 as GuardrailPhase, a2 as GuardrailResult, a3 as GuardrailViolationError, a4 as HitlDecision, a5 as InferAgentInput, a6 as InferAgentToolNames, a7 as IterationEvent, a8 as LLMCallContext, a9 as LoopFinishReason, aa as LoopOutcome, ab as LoopStrategyConfig, ac as MainLoopOptions, ad as McpApprovalSpec, ae as McpRegistryConfig, af as McpRequestContext, ag as McpSelection, ah as PartialToolCallEvent, ai as PolicyHandler, aj as ProcessInputContext, ak as ReflectionContext, al as ReflectionResult, am as ReflectionStrategyConfig, an as RunStartedEvent, ao as ScoreVerdict, ap as ScoredDelegation, aq as Scorer, ar as SdkAgentHandle, as as SdkMessage, at as Segment, au as SkillsRequestContext, av as SkillsSelection, aw as StateUpdateEvent, ax as TextDeltaEvent, ay as ThinkingEvent, az as TimeoutAction, aA as ToolCallEvent, aB as ToolCallVeto, aC as ToolHooks, aD as ToolHooksPlugin, aE as ToolResultEvent, aF as ToolWalkResult, aG as ToolboxOptions, aH as ToolboxWalkResult, aI as agentsPlugin, aJ as buildModelSelection, aK as compileAgentDefinition, aL as compileAgentModule, aM as compileContextWindow, aN as compileProjectContext, aO as compileSkills, aP as compileTools, aQ as createAgentExecutionContext, aR as createApiErrorHandler, aS as createSdkAgentStream, aT as createThinkTagExtractor, aU as createToolHooksPlugin, aV as delegate, aW as delegateBackground, aX as delegateWithScoring, aY as extractThinkTagStream, aZ as generateAgentManifest, a_ as generateAgentRoutes, a$ as isAgentContext, b0 as isAgentDefinition, b1 as isApprovalRequired, b2 as isDone, b3 as isError, b4 as isPartialToolCall, b5 as isTextDelta, b6 as isToolCall, b7 as isToolResult, b8 as ladderReflectionStrategy, b9 as loopStrategyConfigSchema, ba as mcpRegistry, bb as mcpToolApprovals, bc as noopReflectionStrategy, bd as presentUIMessageStream, be as projectContextMetadataOnlyKnobs, bf as reflectionStrategyConfigSchema, bg as resolveEnabledSkills, bh as resolveLoopStrategy, bi as resolveMcpServers, bj as runWithApiErrorHandling, bk as streamAgentResponse, bl as streamAgentUIMessages, bm as toAgentFactory, bn as translateSdkEvent } from './bridge-entry-Ddu3Ug_3.js';
 import { PluginsSettings, Plugin, ProviderRoutingSettings, AgentDefinition, BudgetTracker, CustomTool, InlineSkill } from '@theokit/sdk';
 import { RetryOptions } from '@theokit/sdk/retry';
 import { CompressibleMessage } from '@theokit/sdk/compaction';
@@ -498,10 +497,16 @@ declare class ToolsCapability implements Capability {
     apply(draft: CompiledAgentOptionsDraft): void;
 }
 /**
- * Enables skills by name. FUNCTION, not class: it carries no behavior beyond assignment — a class here
- * would be ceremony (the honest counter-example to "everything must be a class").
+ * Enables skills by name (or inline). M57: a CLASS now (was a factory function). Validation moves to
+ * the constructor — fail-fast at authoring, the same place `ModelCapability`/`AgentConfigCapability`
+ * validate. The `apply` body (delegate + merge) is unchanged, so the compiled output is identical.
  */
-declare const skills: (entries: readonly (string | InlineSkill)[]) => Capability;
+declare class SkillsCapability implements Capability {
+    #private;
+    readonly name = "skills";
+    constructor(entries: readonly (string | InlineSkill)[]);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 
 /**
  * M52 — resolution + composition. The registry is what unlocks FILE-BASED authoring (a config lists
@@ -531,51 +536,122 @@ declare class CapabilityPreset implements Capability {
     apply(draft: CompiledAgentOptionsDraft): void;
 }
 
+/**
+ * M53 — the capabilities that replace the waist-bound agent decorators, one per field the decorator
+ * pipeline produces today (`docs/agents/decorator-to-capability.md` § A).
+ *
+ * M57 reverses ADR 0001 § 4 (which kept the pure-assignment ones as a factory function to avoid
+ * "13 near-identical classes"): the authoring surface is now 100% classes, aligned with the SDK's
+ * `X.create()`/class shape. The `FieldCapability` base keeps the assignment ones DRY (one line each);
+ * the behaviour-carrying ones are written out. Rationale in ADR 0005.
+ */
+/**
+ * Base for a capability whose only job is to assign one waist field — no validation, no merge, no
+ * precedence. M57: this replaces the `fieldCapability(name, field)` factory function with a class, so
+ * the authoring surface is 100% classes (aligned with the SDK's `X.create()` and the existing
+ * `ModelCapability`). The subclasses below are one line each; the shared `apply` lives here (DRY).
+ * NOT the Template-Method the ADR-0001 refused — that was inheritance of variable *behaviour*
+ * (`shouldContinue`); here the base carries *data* (name/field) and `apply` is identical for all.
+ */
+declare abstract class FieldCapability<K extends keyof CompiledAgentOptionsDraft> implements Capability {
+    private readonly value;
+    abstract readonly name: string;
+    protected abstract readonly field: K;
+    constructor(value: NonNullable<CompiledAgentOptionsDraft[K]>);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /** `@Memory` → `memory`. */
-declare const memory: (value: NonNullable<MemoryOptions | _theokit_sdk.MemorySettings | undefined>) => Capability;
+declare class MemoryCapability extends FieldCapability<'memory'> {
+    readonly name = "memory";
+    protected readonly field: "memory";
+}
 /**
  * `@ContextWindow` → `context`. DELEGATES to `compileContextWindow`, which is the canonical
  * `ContextWindowOptions → ContextSettings` conversion (it also reports the metadata-only knobs).
  * Taking a pre-converted value here would duplicate that knowledge — the exact divergence the M52
  * zero-behavior proof caught in `skills`.
  */
-declare const contextWindow: (options: ContextWindowOptions) => Capability;
+declare class ContextWindowCapability implements Capability {
+    private readonly options;
+    readonly name = "context-window";
+    constructor(options: ContextWindowOptions);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /** `@ProjectContext` → `projectContext`. */
-declare const projectContext: (value: ProjectContextOptions) => Capability;
+declare class ProjectContextCapability extends FieldCapability<'projectContext'> {
+    readonly name = "project-context";
+    protected readonly field: "projectContext";
+}
 /** `@MCP` → `mcpServers`. */
-declare const mcpServers: (value: McpServersMap) => Capability;
+declare class McpServersCapability extends FieldCapability<'mcpServers'> {
+    readonly name = "mcp";
+    protected readonly field: "mcpServers";
+}
 /** `@Guardrails` → `guardrails`. */
-declare const guardrails: (value: readonly Guardrail[]) => Capability;
+declare class GuardrailsCapability extends FieldCapability<'guardrails'> {
+    readonly name = "guardrails";
+    protected readonly field: "guardrails";
+}
 /**
  * `@Checkpoint` → `checkpoint`. Carries the non-durable WARNING the metadata walk used to emit: only
  * `'filesystem'` selects the SDK's durable store, so any other storage cannot resume across
  * requests. The warning moves WITH the feature — a declared checkpoint that silently cannot resume
  * is exactly the kind of no-op this project refuses to ship.
  */
-declare const checkpoint: (options: CompiledAgentOptions["checkpoint"]) => Capability;
+declare class CheckpointCapability implements Capability {
+    private readonly options;
+    readonly name = "checkpoint";
+    constructor(options: CompiledAgentOptions['checkpoint']);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /**
  * `@HumanInTheLoop` → `hitl`, keyed `"<namespace>_<tool>"` — the same key `compileHitlGates` mints
  * via `toolRuntimeName`. The separator is `_`, not `.`: the dot is outside the charset the SDK
  * accepts, and a gate keyed with a dot silently failed to match its tool (theokit#145).
  */
-declare const humanInTheLoop: (value: Map<string, HumanInTheLoopOptions>) => Capability;
+declare class HumanInTheLoopCapability extends FieldCapability<'hitl'> {
+    readonly name = "human-in-the-loop";
+    protected readonly field: "hitl";
+}
 /**
  * `@SubAgents` → `agents`. MERGES instead of `setOnce`: `agents` is a pre-seeded collection on the
  * draft (`createDraft` gives it `{}`), so a `setOnce` would conflict against the seed itself — the
  * same trap the pre-seeded `stream` sprang in M52. Merging also lets a preset declare a baseline
  * child set that a call site extends.
  */
-declare const subAgents: (children: CompiledAgentOptions["agents"]) => Capability;
+declare class SubAgentsCapability implements Capability {
+    private readonly children;
+    readonly name = "sub-agents";
+    constructor(children: CompiledAgentOptions['agents']);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /**
  * `@Skills({ include, autoDiscover })` → `skills`. Delegates to `compileSkills` (same reason as
  * `contextWindow`). Distinct from the M52 `skills([...])`, which takes the plain name/inline list.
  */
-declare const skillsOptions: (options: SkillsOptions) => Capability;
+declare class SkillsOptionsCapability implements Capability {
+    private readonly options;
+    readonly name = "skills";
+    constructor(options: SkillsOptions);
+    apply(draft: CompiledAgentOptionsDraft): void;
+}
 /** Functional-path fields that had no decorator source — closing the gap list, not adding surface. */
-declare const settingSources: (value: readonly _theokit_sdk.SettingSource[]) => Capability;
-declare const plugins: (value: readonly unknown[]) => Capability;
-declare const runContext: (value: Record<string, unknown>) => Capability;
-declare const skillsResolver: (value: NonNullable<SkillsSelection | undefined>) => Capability;
+declare class SettingSourcesCapability extends FieldCapability<'settingSources'> {
+    readonly name = "setting-sources";
+    protected readonly field: "settingSources";
+}
+declare class PluginsCapability extends FieldCapability<'plugins'> {
+    readonly name = "plugins";
+    protected readonly field: "plugins";
+}
+declare class RunContextCapability extends FieldCapability<'runContext'> {
+    readonly name = "run-context";
+    protected readonly field: "runContext";
+}
+declare class SkillsResolverCapability extends FieldCapability<'skillsResolver'> {
+    readonly name = "skills-resolver";
+    protected readonly field: "skillsResolver";
+}
 /** The scalar agent config (name/route are HTTP concerns, never agent config). */
 interface AgentConfig {
     readonly systemPrompt?: CompiledAgentOptions['systemPrompt'];
@@ -872,4 +948,4 @@ declare class AcpClient {
     private handleServerRequest;
 }
 
-export { type A2AAuth, type A2ACapabilities, type A2ASkill, type A2AToolConfig, AcpClient, AcpMessageDecoder, type AcpTransport, type AgentCard, type AgentConfig, AgentConfigCapability, AgentManifestEntry, AgentRunner, AgentRunnerBuilder, type AgentRunnerRunOptions, ApprovalOptions, type BuildAgentCardOptions, type Capability, CapabilityConflictError, CapabilityPreset, CapabilityRegistry, type CompactionCallOptions, type CompactionStrategyConfig, CompiledAgentOptions, type CompiledAgentOptionsDraft, CompiledTool, ConfigurationError, type CostGuardOptions, DEFAULT_KEEP_TOKENS, DelegationResult, type FinalizedDraft, Guardrail, HumanInTheLoopOptions, LoopStrategy, MCP_PROTOCOL_VERSION, MainLoopCapability, MainLoopMeta, type McpJsonSchema, type McpServerInfo, type McpToolDescriptor, ModelCapability, type OutputModerationOptions, type PiiOptions, type PromptInjectionOptions, type ProvenanceEntry, ReasoningEffort, ReflectionStrategy, RoundStreamFactory, SkillsSelection, StreamEvent, type Summarize, type ToolDeclaration, ToolOptions, ToolboxCapability, type ToolboxSource, ToolsCapability, type TranscriptCompactionStrategy, UnknownCapabilityError, applyCapabilities, buildAgentCard, buildMcpToolDescriptors, checkpoint, compactionStrategyConfigSchema, contextWindow, costGuard, createA2ATool, createDraft, deriveConversationId, encodeAcpMessage, estimateTokens, guardrails, humanInTheLoop, mcpServerInfo, mcpServers, memory, moderateOutputStream, outputModeration, parseConversationId, piiDetector, plugins, projectContext, promptInjectionDetector, resolveCompactionStrategy, runContext, runInputGuards, runOutputGuards, setOnce, settingSources, skills, skillsOptions, skillsResolver, subAgents, tokenBudgetCompactionStrategy, unicodeNormalizer, wellKnownCardPath };
+export { type A2AAuth, type A2ACapabilities, type A2ASkill, type A2AToolConfig, AcpClient, AcpMessageDecoder, type AcpTransport, type AgentCard, type AgentConfig, AgentConfigCapability, AgentManifestEntry, AgentRunner, AgentRunnerBuilder, type AgentRunnerRunOptions, ApprovalOptions, type BuildAgentCardOptions, type Capability, CapabilityConflictError, CapabilityPreset, CapabilityRegistry, CheckpointCapability, type CompactionCallOptions, type CompactionStrategyConfig, CompiledAgentOptions, type CompiledAgentOptionsDraft, CompiledTool, ConfigurationError, ContextWindowCapability, type CostGuardOptions, DEFAULT_KEEP_TOKENS, DelegationResult, FieldCapability, type FinalizedDraft, Guardrail, GuardrailsCapability, HumanInTheLoopCapability, HumanInTheLoopOptions, LoopStrategy, MCP_PROTOCOL_VERSION, MainLoopCapability, MainLoopMeta, type McpJsonSchema, type McpServerInfo, McpServersCapability, type McpToolDescriptor, MemoryCapability, ModelCapability, type OutputModerationOptions, type PiiOptions, PluginsCapability, ProjectContextCapability, type PromptInjectionOptions, type ProvenanceEntry, ReasoningEffort, ReflectionStrategy, RoundStreamFactory, RunContextCapability, SettingSourcesCapability, SkillsCapability, SkillsOptionsCapability, SkillsResolverCapability, StreamEvent, SubAgentsCapability, type Summarize, type ToolDeclaration, ToolOptions, ToolboxCapability, type ToolboxSource, ToolsCapability, type TranscriptCompactionStrategy, UnknownCapabilityError, applyCapabilities, buildAgentCard, buildMcpToolDescriptors, compactionStrategyConfigSchema, costGuard, createA2ATool, createDraft, deriveConversationId, encodeAcpMessage, estimateTokens, mcpServerInfo, moderateOutputStream, outputModeration, parseConversationId, piiDetector, promptInjectionDetector, resolveCompactionStrategy, runInputGuards, runOutputGuards, setOnce, tokenBudgetCompactionStrategy, unicodeNormalizer, wellKnownCardPath };

package/dist/index.js

@@ -1,16 +1,17 @@
 import {
   AGENT_BRAND,
+  AgentBuilder,
   AgentDefinitionError,
   AgentRunner,
   AgentRunnerBuilder,
   BudgetExceededError,
   ConfigurationError,
+  ContextualTool,
   CostBudgetExceededError,
   DEFAULT_KEEP_TOKENS,
   DEFAULT_MAX_ITERATIONS,
   DelegationError,
   GuardrailViolationError,
-  agent,
   agentsPlugin,
   buildModelSelection,
   compactionStrategyConfigSchema,
@@ -22,7 +23,6 @@ import {
   compileSkills,
   compileSkillsSelection,
   compileTools,
-  contextualTool,
   costGuard,
   createAgentExecutionContext,
   createApiErrorHandler,
@@ -70,7 +70,7 @@ import {
   toolRuntimeName,
   translateSdkEvent,
   unicodeNormalizer
-} from "./chunk-C2DALG62.js";
+} from "./chunk-OKG5LRGV.js";
 import {
   __name
 } from "./chunk-7QVYU63E.js";
@@ -177,66 +177,71 @@ var ToolsCapability = class {
     });
   }
 };
-var skills = /* @__PURE__ */ __name((entries) => {
-  if (!Array.isArray(entries)) {
-    throw new ConfigurationError(`skills: esperava array de nomes, recebi ${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");
-      }
-      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`);
+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)}`);
     }
-    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`);
+    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");
+        }
+        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`);
+      }
+      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`);
+        }
       }
     }
+    this.#entries = entries;
   }
-  return {
-    name: "skills",
-    apply: /* @__PURE__ */ __name((draft) => {
-      const compiled = compileSkillsSelection(entries.slice());
-      if (compiled.skills === void 0) return;
-      const previous = draft.skills;
-      draft.skills = previous === void 0 ? compiled.skills : {
-        // The spread is exhaustive only because `compileSkillsSelection` emits a FIXED 3-key
-        // shape (`enabled`, `autoInject: true`, and `inline` iff non-empty) — `enabled` and
-        // `inline` are both re-derived below, and `autoInject` is the same literal on both
-        // sides. TRAP for the future: if a capability ever authors `autoInject: false`, this
-        // spread would silently normalize it back to `true`. Unreachable today (no capability
-        // 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 ?? []
-          ]
-        } : {}
-      };
-      draft.provenance.push({
-        capability: "skills",
-        contributed: [
-          "skills"
+  apply(draft) {
+    const compiled = compileSkillsSelection(this.#entries.slice());
+    if (compiled.skills === void 0) return;
+    const previous = draft.skills;
+    draft.skills = previous === void 0 ? compiled.skills : {
+      // The spread is exhaustive only because `compileSkillsSelection` emits a FIXED 3-key
+      // shape (`enabled`, `autoInject: true`, and `inline` iff non-empty) — `enabled` and
+      // `inline` are both re-derived below, and `autoInject` is the same literal on both
+      // sides. TRAP for the future: if a capability ever authors `autoInject: false`, this
+      // spread would silently normalize it back to `true`. Unreachable today (no capability
+      // 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 ?? []
         ]
-      });
-    }, "apply")
-  };
-}, "skills");
+      } : {}
+    };
+    draft.provenance.push({
+      capability: this.name,
+      contributed: [
+        "skills"
+      ]
+    });
+  }
+};
 
 // src/capability/registry.ts
 var UnknownCapabilityError = class extends Error {
@@ -287,62 +292,147 @@ var CapabilityPreset = class {
 };
 
 // src/capability/agent-capabilities.ts
-function fieldCapability(name, field) {
-  return (value) => ({
-    name,
-    apply: /* @__PURE__ */ __name((draft) => {
-      setOnce(draft, field, value, name);
-    }, "apply")
-  });
-}
-__name(fieldCapability, "fieldCapability");
-var memory = fieldCapability("memory", "memory");
-var contextWindow = /* @__PURE__ */ __name((options) => ({
-  name: "context-window",
-  apply: /* @__PURE__ */ __name((draft) => {
-    setOnce(draft, "context", compileContextWindow(options).context, "context-window");
-  }, "apply")
-}), "contextWindow");
-var projectContext = fieldCapability("project-context", "projectContext");
-var mcpServers = fieldCapability("mcp", "mcpServers");
-var guardrails = fieldCapability("guardrails", "guardrails");
-var checkpoint = /* @__PURE__ */ __name((options) => ({
-  name: "checkpoint",
-  apply: /* @__PURE__ */ __name((draft) => {
-    if (options !== void 0 && options.storage !== "filesystem") {
-      console.warn(`[THEO_AGENT_CHECKPOINT_STORAGE_METADATA_ONLY] checkpoint({ storage: '${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.`);
+var FieldCapability = class {
+  static {
+    __name(this, "FieldCapability");
+  }
+  value;
+  constructor(value) {
+    this.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;
+  }
+  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;
+  }
+  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.`);
     }
-    setOnce(draft, "checkpoint", options, "checkpoint");
-  }, "apply")
-}), "checkpoint");
-var humanInTheLoop = fieldCapability("human-in-the-loop", "hitl");
-var subAgents = /* @__PURE__ */ __name((children) => ({
-  name: "sub-agents",
-  apply: /* @__PURE__ */ __name((draft) => {
-    for (const [name, child] of Object.entries(children)) {
+    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;
+  }
+  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`);
       }
       draft.agents[name] = child;
     }
     draft.provenance.push({
-      capability: "sub-agents",
+      capability: this.name,
       contributed: [
         "agents"
       ]
     });
-  }, "apply")
-}), "subAgents");
-var skillsOptions = /* @__PURE__ */ __name((options) => ({
-  name: "skills",
-  apply: /* @__PURE__ */ __name((draft) => {
-    setOnce(draft, "skills", compileSkills(options), "skills");
-  }, "apply")
-}), "skillsOptions");
-var settingSources = fieldCapability("setting-sources", "settingSources");
-var plugins = fieldCapability("plugins", "plugins");
-var runContext = fieldCapability("run-context", "runContext");
-var skillsResolver = fieldCapability("skills-resolver", "skillsResolver");
+  }
+};
+var SkillsOptionsCapability = class {
+  static {
+    __name(this, "SkillsOptionsCapability");
+  }
+  options;
+  name = "skills";
+  constructor(options) {
+    this.options = options;
+  }
+  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");
@@ -773,6 +863,7 @@ export {
   AGENT_BRAND,
   AcpClient,
   AcpMessageDecoder,
+  AgentBuilder,
   AgentConfigCapability,
   AgentDefinitionError,
   AgentRunner,
@@ -781,25 +872,39 @@ export {
   CapabilityConflictError,
   CapabilityPreset,
   CapabilityRegistry,
+  CheckpointCapability,
   ConfigurationError,
+  ContextWindowCapability,
+  ContextualTool,
   CostBudgetExceededError,
   DEFAULT_KEEP_TOKENS,
   DEFAULT_MAX_ITERATIONS,
   DelegationError,
+  FieldCapability,
   GuardrailViolationError,
+  GuardrailsCapability,
+  HumanInTheLoopCapability,
   MCP_PROTOCOL_VERSION,
   MainLoopCapability,
+  McpServersCapability,
+  MemoryCapability,
   ModelCapability,
+  PluginsCapability,
+  ProjectContextCapability,
+  RunContextCapability,
+  SettingSourcesCapability,
+  SkillsCapability,
+  SkillsOptionsCapability,
+  SkillsResolverCapability,
+  SubAgentsCapability,
   ToolboxCapability,
   ToolsCapability,
   UnknownCapabilityError,
-  agent,
   agentsPlugin,
   applyCapabilities,
   buildAgentCard,
   buildMcpToolDescriptors,
   buildModelSelection,
-  checkpoint,
   compactionStrategyConfigSchema,
   compileAgentDefinition,
   compileAgentModule,
@@ -807,8 +912,6 @@ export {
   compileProjectContext,
   compileSkills,
   compileTools,
-  contextWindow,
-  contextualTool,
   costGuard,
   createA2ATool,
   createAgentExecutionContext,
@@ -826,8 +929,6 @@ export {
   extractThinkTagStream,
   generateAgentManifest,
   generateAgentRoutes,
-  guardrails,
-  humanInTheLoop,
   isAgentContext,
   isAgentDefinition,
   isApprovalRequired,
@@ -841,17 +942,13 @@ export {
   loopStrategyConfigSchema,
   mcpRegistry,
   mcpServerInfo,
-  mcpServers,
   mcpToolApprovals,
-  memory,
   moderateOutputStream,
   noopReflectionStrategy,
   outputModeration,
   parseConversationId,
   piiDetector,
-  plugins,
   presentUIMessageStream,
-  projectContext,
   projectContextMetadataOnlyKnobs,
   promptInjectionDetector,
   reflectionStrategyConfigSchema,
@@ -859,18 +956,12 @@ export {
   resolveEnabledSkills,
   resolveLoopStrategy,
   resolveMcpServers,
-  runContext,
   runInputGuards,
   runOutputGuards,
   runWithApiErrorHandling,
   setOnce,
-  settingSources,
-  skills,
-  skillsOptions,
-  skillsResolver,
   streamAgentResponse,
   streamAgentUIMessages,
-  subAgents,
   toAgentFactory,
   tokenBudgetCompactionStrategy,
   translateSdkEvent,