@deepstrike/sdk 0.1.15 → 0.2.0

package/dist/collaboration/harness.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPool } from "./pool.js";
+import type { AgentPool, CoordinatorConfig } from "./pool.js";
 import type { VerificationContract, ContractCheckResult } from "./contract.js";
 import type { HandoffArtifact } from "./handoff.js";
 export interface Violation {
@@ -17,6 +17,8 @@ export interface ContractOutcome {
 export interface ContractHarnessOptions {
     maxAttempts?: number;
     onViolation?: (violations: Violation[]) => void;
+    /** When set with pool.configureCoordinator(), enables kernel spawn path. */
+    coordinator?: CoordinatorConfig;
 }
 /**
  * ContractDrivenHarness — the core multi-agent execution primitive.
@@ -41,6 +43,7 @@ export declare class ContractDrivenHarness {
     private maxAttempts;
     private onViolation?;
     constructor(pool: AgentPool, contract: VerificationContract, options?: ContractHarnessOptions);
+    stream(): AsyncIterable<ContractOutcome>;
     run(): Promise<ContractOutcome>;
     private _findViolations;
     private _formatViolationsForFeedback;

package/dist/collaboration/harness.js

@@ -28,6 +28,12 @@ export class ContractDrivenHarness {
         this.contract = contract;
         this.maxAttempts = options.maxAttempts ?? 3;
         this.onViolation = options.onViolation;
+        if (options.coordinator) {
+            this.pool.configureCoordinator(options.coordinator.opts, options.coordinator.sessionId);
+        }
+    }
+    async *stream() {
+        yield await this.run();
     }
     async run() {
         let artifact = "";
@@ -43,14 +49,22 @@ export class ContractDrivenHarness {
                 ? `\n\n[Previous attempt failed. Violations to fix:\n${this._formatViolationsForFeedback(checkResults)}]`
                 : "";
             const executorGoal = `${contractBlock}\n\n---\n\n${currentGoal}${violationNote}`;
-            artifact = await collectText(this.pool.get("executor").run({
-                sessionId: crypto.randomUUID(),
-                goal: executorGoal,
-                criteria: contractToCriteriaStrings(this.contract),
-            }));
+            if (this.pool.usesSpawnPath()) {
+                const execResult = await this.pool.spawn("executor", executorGoal, {
+                    verificationContractId: this.contract.id,
+                });
+                artifact = execResult.result.finalMessage?.content ?? "";
+            }
+            else {
+                artifact = await collectText(this.pool.get("executor").run({
+                    sessionId: crypto.randomUUID(),
+                    goal: executorGoal,
+                    criteria: contractToCriteriaStrings(this.contract),
+                }));
+            }
             // ── Phase 2: Verifier ──────────────────────────────────────────────────
             // Verifier sees: artifact + contract only. No executor history.
-            const auditText = await this.pool.runVerifier({ contract: this.contract, artifact });
+            const auditText = await this.pool.verify({ contract: this.contract, artifact });
             // ── Phase 3: Parse audit → ContractCheckResult[] ──────────────────────
             checkResults = this._parseAuditText(auditText);
             const violations = this._findViolations(checkResults);

package/dist/collaboration/modes/creator-verifier.d.ts

@@ -9,8 +9,8 @@ export interface CreatorVerifierMetrics {
 /**
  * CreatorVerifierMode — the simplest multi-agent collaboration pattern.
  *
- * Wires an executor + verifier from an AgentPool into a ContractDrivenHarness.
- * The executor creates, the verifier audits. Contexts are fully isolated.
+ * By default uses the kernel spawn path via `pool.ensureCoordinator()`.
+ * Pass `useLegacyRunners: true` to fall back to independent runner sessions.
  *
  * Usage:
  * ```ts
@@ -33,6 +33,10 @@ export declare class CreatorVerifierMode {
     private _failed;
     constructor(pool: AgentPool, options?: {
         maxAttempts?: number;
+        /** Stable orchestration session for kernel lineage audit. */
+        coordinatorSessionId?: string;
+        /** Opt out of kernel spawn path and use legacy independent runner sessions. */
+        useLegacyRunners?: boolean;
     });
     run(contract: VerificationContract): Promise<ContractOutcome>;
     /** Aggregate drift metrics across all runs through this mode instance. */
@@ -59,6 +63,8 @@ export declare class OrchestrationMode {
     private inner;
     constructor(pool: AgentPool, options?: {
         maxAttempts?: number;
+        coordinatorSessionId?: string;
+        useLegacyRunners?: boolean;
     });
     run(goal: string): Promise<ContractOutcome & {
         contract: VerificationContract;

package/dist/collaboration/modes/creator-verifier.js

@@ -2,8 +2,8 @@ import { ContractDrivenHarness } from "../harness.js";
 /**
  * CreatorVerifierMode — the simplest multi-agent collaboration pattern.
  *
- * Wires an executor + verifier from an AgentPool into a ContractDrivenHarness.
- * The executor creates, the verifier audits. Contexts are fully isolated.
+ * By default uses the kernel spawn path via `pool.ensureCoordinator()`.
+ * Pass `useLegacyRunners: true` to fall back to independent runner sessions.
  *
  * Usage:
  * ```ts
@@ -30,6 +30,9 @@ export class CreatorVerifierMode {
     }
     async run(contract) {
         this._total++;
+        if (!this.options.useLegacyRunners) {
+            this.pool.ensureCoordinator(this.options.coordinatorSessionId);
+        }
         const harness = new ContractDrivenHarness(this.pool, contract, {
             maxAttempts: this.options.maxAttempts ?? 3,
         });
@@ -78,8 +81,11 @@ export class OrchestrationMode {
         this.inner = new CreatorVerifierMode(pool, options);
     }
     async run(goal) {
+        if (!this.options.useLegacyRunners) {
+            this.pool.ensureCoordinator(this.options.coordinatorSessionId);
+        }
         // Step 1: orchestrator produces a VerificationContract
-        const contractJson = await this.pool.runOrchestrator(goal);
+        const contractJson = await this.pool.orchestrate(goal);
         const contract = this._parseContract(contractJson, goal);
         // Step 2: CreatorVerifierMode executes against the contract
         const outcome = await this.inner.run(contract);

package/dist/collaboration/pool.d.ts

@@ -1,15 +1,36 @@
-import type { RuntimeRunner } from "../runtime/runner.js";
+import type { RuntimeOptions, RuntimeRunner } from "../runtime/runner.js";
 import type { VerificationContract } from "./contract.js";
+import type { AgentRunSpec, KernelAgentRole, SubAgentResult } from "../types/agent.js";
+/** Legacy pool roles — mapped to kernel AgentRole when using spawn path. */
 export type AgentRole = "orchestrator" | "executor" | "verifier";
+export declare const KERNEL_ROLE_MAP: Record<AgentRole, KernelAgentRole>;
 export interface IsolatedVerifierContext {
     contract: VerificationContract;
     artifact: string;
 }
+export interface CoordinatorConfig {
+    opts: RuntimeOptions;
+    sessionId: string;
+}
 export declare class AgentPool {
     private runners;
+    private coordinator?;
     add(role: AgentRole, runner: RuntimeRunner): this;
+    /** Enable kernel spawn path with lineage recorded under `sessionId`. */
+    configureCoordinator(opts: RuntimeOptions, sessionId: string): this;
+    /**
+     * Infer coordinator from a registered runner (executor → orchestrator → verifier).
+     * Idempotent when coordinator is already configured.
+     */
+    ensureCoordinator(sessionId?: string): this;
+    usesSpawnPath(): boolean;
     has(role: AgentRole): boolean;
     get(role: AgentRole): RuntimeRunner;
-    runVerifier(ctx: IsolatedVerifierContext): Promise<string>;
-    runOrchestrator(goal: string): Promise<string>;
+    /**
+     * Spawn a kernel-isolated sub-agent. Requires `configureCoordinator()`.
+     * Maps legacy pool roles to kernel roles (executor → implement, etc.).
+     */
+    spawn(role: AgentRole | KernelAgentRole, goal: string, extra?: Partial<Omit<AgentRunSpec, "identity" | "role" | "goal">>): Promise<SubAgentResult>;
+    verify(ctx: IsolatedVerifierContext): Promise<string>;
+    orchestrate(goal: string): Promise<string>;
 }

package/dist/collaboration/pool.js

@@ -1,11 +1,41 @@
 import { collectText } from "../runtime/runner.js";
+import { spawnStandalone } from "../runtime/sub-agent-orchestrator.js";
 import { formatContractForSystemPrompt } from "./contract.js";
+import { agentIdentitySub } from "../types/agent.js";
+export const KERNEL_ROLE_MAP = {
+    orchestrator: "plan",
+    executor: "implement",
+    verifier: "verify",
+};
 export class AgentPool {
     runners = new Map();
+    coordinator;
     add(role, runner) {
         this.runners.set(role, runner);
         return this;
     }
+    /** Enable kernel spawn path with lineage recorded under `sessionId`. */
+    configureCoordinator(opts, sessionId) {
+        this.coordinator = { opts, sessionId };
+        return this;
+    }
+    /**
+     * Infer coordinator from a registered runner (executor → orchestrator → verifier).
+     * Idempotent when coordinator is already configured.
+     */
+    ensureCoordinator(sessionId) {
+        if (this.coordinator)
+            return this;
+        const source = this.has("executor")
+            ? "executor"
+            : this.has("orchestrator")
+                ? "orchestrator"
+                : "verifier";
+        return this.configureCoordinator(this.get(source).hostOptions, sessionId ?? crypto.randomUUID());
+    }
+    usesSpawnPath() {
+        return this.coordinator !== undefined;
+    }
     has(role) {
         return this.runners.has(role);
     }
@@ -15,8 +45,24 @@ export class AgentPool {
             throw new Error(`AgentPool: no runner registered for role "${role}"`);
         return runner;
     }
-    async runVerifier(ctx) {
-        const runner = this.get("verifier");
+    /**
+     * Spawn a kernel-isolated sub-agent. Requires `configureCoordinator()`.
+     * Maps legacy pool roles to kernel roles (executor → implement, etc.).
+     */
+    async spawn(role, goal, extra) {
+        if (!this.coordinator) {
+            throw new Error("AgentPool.configureCoordinator() required for kernel spawn path");
+        }
+        const kernelRole = role in KERNEL_ROLE_MAP ? KERNEL_ROLE_MAP[role] : role;
+        const spec = {
+            identity: agentIdentitySub(`${kernelRole}-${crypto.randomUUID()}`, crypto.randomUUID(), this.coordinator.sessionId),
+            role: kernelRole,
+            goal,
+            ...extra,
+        };
+        return spawnStandalone(this.coordinator.opts, this.coordinator.sessionId, spec);
+    }
+    async verify(ctx) {
         const contractBlock = formatContractForSystemPrompt(ctx.contract);
         const auditGoal = [
             contractBlock, "",
@@ -29,10 +75,17 @@ export class AgentPool {
             "List any anti-patterns you detected.",
             "Conclude with an overall PASS or FAIL verdict.",
         ].join("\n");
+        if (this.coordinator) {
+            const result = await this.spawn("verify", auditGoal, {
+                verificationContractId: ctx.contract.id,
+                isolation: "read_only",
+            });
+            return result.result.finalMessage?.content ?? "";
+        }
+        const runner = this.get("verifier");
         return collectText(runner.run({ sessionId: crypto.randomUUID(), goal: auditGoal }));
     }
-    async runOrchestrator(goal) {
-        const runner = this.get("orchestrator");
+    async orchestrate(goal) {
         const orchestratorGoal = [
             `You are a planning orchestrator. Decompose the following goal into a VerificationContract.`,
             ``,
@@ -49,6 +102,13 @@ export class AgentPool {
             ``,
             `Output ONLY the JSON object, no prose.`,
         ].join("\n");
-        return collectText(runner.run({ sessionId: crypto.randomUUID(), goal: orchestratorGoal }));
+        if (this.coordinator) {
+            const result = await this.spawn("plan", orchestratorGoal);
+            return result.result.finalMessage?.content ?? "";
+        }
+        return collectText(this.get("orchestrator").run({
+            sessionId: crypto.randomUUID(),
+            goal: orchestratorGoal,
+        }));
     }
 }

package/dist/harness/harness.d.ts

@@ -1,5 +1,6 @@
 import type { RuntimeRunner } from "../runtime/runner.js";
 import { collectText } from "../runtime/runner.js";
+import type { StreamEvent } from "../types.js";
 export interface Criterion {
     text: string;
     required: boolean;
@@ -75,6 +76,7 @@ export declare class SinglePassHarness {
     private runner;
     constructor(runner: RuntimeRunner);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
+    stream(request: HarnessRequest): AsyncIterable<StreamEvent>;
 }
 export declare class EvalLoopHarness {
     private runner;
@@ -82,6 +84,7 @@ export declare class EvalLoopHarness {
     private maxAttempts;
     constructor(runner: RuntimeRunner, gate: QualityGate, maxAttempts?: number);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
+    stream(request: HarnessRequest): AsyncIterable<StreamEvent>;
 }
 export interface HarnessLoopOptions {
     maxAttempts?: number;
@@ -93,6 +96,7 @@ export declare class HarnessLoop {
     private maxAttempts;
     private skillDir?;
     constructor(runner: RuntimeRunner, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
-    runStreaming(request: HarnessRequest): AsyncIterable<HarnessEvent>;
+    run(request: HarnessRequest): Promise<HarnessOutcome>;
+    stream(request: HarnessRequest): AsyncIterable<HarnessEvent>;
 }
 export { collectText };

package/dist/harness/harness.js

@@ -22,6 +22,9 @@ export class SinglePassHarness {
     async run(request) {
         return { ...await runOnce(this.runner, request), passed: true };
     }
+    async *stream(request) {
+        yield* this.runner.run({ sessionId: crypto.randomUUID(), goal: request.goal, criteria: request.criteria?.map(c => c.text), extensions: request.extensions });
+    }
 }
 export class EvalLoopHarness {
     runner;
@@ -41,6 +44,9 @@ export class EvalLoopHarness {
         }
         return outcome;
     }
+    async *stream(request) {
+        yield* this.runner.run({ sessionId: crypto.randomUUID(), goal: request.goal, criteria: request.criteria?.map(c => c.text), extensions: request.extensions });
+    }
 }
 export class HarnessLoop {
     runner;
@@ -53,7 +59,23 @@ export class HarnessLoop {
         this.maxAttempts = options.maxAttempts ?? 3;
         this.skillDir = options.skillDir;
     }
-    async *runStreaming(request) {
+    async run(request) {
+        let last;
+        for await (const evt of this.stream(request))
+            last = evt;
+        const done = last?.type === "done" ? last : undefined;
+        return {
+            result: "",
+            passed: done?.verdict.passed ?? false,
+            iterations: done?.iterations ?? 0,
+            totalTokens: done?.totalTokens ?? 0,
+            status: done?.status ?? "error",
+            overallScore: done?.verdict.overallScore,
+            feedback: done?.verdict.feedback,
+            details: done?.verdict.details,
+        };
+    }
+    async *stream(request) {
         const kernel = getKernel();
         const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
         const criteria = request.criteria ?? [];

package/dist/index.d.ts

@@ -1,9 +1,14 @@
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
 export type { RuntimeOptions } from "./runtime/runner.js";
+export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
+export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
+export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export type { ExecutionPlane, RunContext } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
 export type { SessionLog, SessionEvent } from "./runtime/session-log.js";
+export { NullArchiveStore, FileArchiveStore } from "./runtime/archive.js";
+export type { ArchiveStore } from "./runtime/archive.js";
 export { EnvCredentialVault, InMemoryCredentialVault, ChainedCredentialVault } from "./runtime/credential-vault.js";
 export type { CredentialVault } from "./runtime/credential-vault.js";
 export { ProcessSandboxPlane } from "./runtime/process-sandbox-plane.js";
@@ -25,6 +30,7 @@ export { OpenAIChatAdapter } from "./providers/openai-chat.js";
 export { OpenAIResponsesAdapter, OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export type { OpenAIResponsesRunState } from "./providers/openai-responses.js";
 export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
+export type { ModelProfileId, ProviderId } from "./providers/profiles.js";
 export { createProvider } from "./providers/catalog.js";
 export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
 export { tool, streamingTool, executeTools, readFile, validateToolArguments } from "./tools/index.js";
@@ -44,10 +50,13 @@ export type { GovernanceVerdict } from "./governance.js";
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate } from "./harness/harness.js";
 export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, ProviderReplay, RenderedContext, } from "./types.js";
+export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentSpawnedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, } from "./types/agent.js";
+export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, } from "./types/agent.js";
 export type { AcceptanceCriterion, VerificationContract, ContractCheckResult, } from "./collaboration/contract.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";
-export type { AgentRole, IsolatedVerifierContext } from "./collaboration/pool.js";
+export type { AgentRole, IsolatedVerifierContext, CoordinatorConfig } from "./collaboration/pool.js";
+export { KERNEL_ROLE_MAP } from "./collaboration/pool.js";
 export { ContractDrivenHarness } from "./collaboration/harness.js";
 export type { ContractOutcome, ContractHarnessOptions, Violation } from "./collaboration/harness.js";
 export { HandoffBus } from "./collaboration/handoff.js";

package/dist/index.js

@@ -1,7 +1,10 @@
 // ── Runtime (Layer 1.5) ────────────────────────────────────────────────────
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
+export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
+export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
+export { NullArchiveStore, FileArchiveStore } from "./runtime/archive.js";
 export { EnvCredentialVault, InMemoryCredentialVault, ChainedCredentialVault } from "./runtime/credential-vault.js";
 export { ProcessSandboxPlane } from "./runtime/process-sandbox-plane.js";
 export { McpProxyPlane } from "./runtime/mcp-proxy-plane.js";
@@ -32,8 +35,10 @@ export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export { Governance } from "./governance.js";
 // ── Harness ────────────────────────────────────────────────────────────────
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
+export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, } from "./types/agent.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";
+export { KERNEL_ROLE_MAP } from "./collaboration/pool.js";
 export { ContractDrivenHarness } from "./collaboration/harness.js";
 export { HandoffBus } from "./collaboration/handoff.js";
 export { CreatorVerifierMode, OrchestrationMode } from "./collaboration/modes/creator-verifier.js";

package/dist/kernel.d.ts

@@ -1,5 +1,4 @@
-import type { Message, RenderedContext, ToolCall, ToolResult, ToolSchema } from "./types.js";
-import type { SkillMetadata } from "./skills/loader.js";
+import type { Message, RenderedContext } from "./types.js";
 export interface GovernanceVerdict {
     kind: "allow" | "deny" | "rate_limited" | "ask_user";
     reason?: string;
@@ -26,45 +25,6 @@ export interface RuntimeSignal {
     dedupeKey?: string;
     timestampMs: number;
 }
-export interface LoopAction {
-    kind: "call_llm" | "execute_tools" | "done";
-    context?: RenderedContext;
-    tools?: ToolSchema[];
-    calls?: ToolCall[];
-    result?: {
-        termination: string;
-        turnsUsed: number;
-        totalTokensUsed: bigint;
-    };
-}
-interface LoopObservation {
-    kind: "compressed";
-    action?: string;
-    rhoAfter?: number;
-}
-interface LoopStateMachineInstance {
-    setAvailableSkills(skills: SkillMetadata[]): void;
-    setMemoryEnabled(enabled: boolean): void;
-    setKnowledgeEnabled(enabled: boolean): void;
-    addSystemMessage(content: string, tokens: number): void;
-    addMemoryMessage(content: string, tokens: number): void;
-    addHistoryMessage(message: Message, tokens: number): void;
-    setTools(tools: ToolSchema[]): void;
-    start(task: {
-        goal: string;
-        criteria: string[];
-    }): LoopAction;
-    resumeAfterPreload(): LoopAction;
-    feedLlmResponse(message: Message): LoopAction;
-    feedToolResults(results: ToolResult[]): LoopAction;
-    feedTimeout(): LoopAction;
-    isTerminal(): boolean;
-    preloadHistory(messages: Message[]): void;
-    drainNewMessages(): Message[];
-    readonly turn: number;
-    pressure(): number;
-    takeObservations(): LoopObservation[];
-}
 interface SignalRouterInstance {
     ingest(signal: RuntimeSignal, isRunning: boolean): string;
     next(): RuntimeSignal | null;
@@ -135,14 +95,23 @@ interface IdlePipelineInstance {
     }>, nowMs: number): IdlePipelineAction;
     feedSynthesisResult(content: string): IdlePipelineAction;
 }
+export interface KernelRuntimeInstance {
+    step(inputJson: string): string;
+    isTerminal(): boolean;
+    turn(): number;
+    recoveryContentBytes(): number;
+    render(): RenderedContext;
+    drainNewMessages(): Message[];
+    preservedRefs(): string[];
+}
 interface KernelModule {
     Governance: new (defaultAction?: "allow" | "deny" | "ask_user") => GovernanceInstance;
-    LoopStateMachine: new (policy: {
+    KernelRuntime: new (policy: {
         maxTokens: number;
         maxTurns?: number;
         maxTotalTokens?: bigint;
         timeoutMs?: bigint;
-    }) => LoopStateMachineInstance;
+    }) => KernelRuntimeInstance;
     SignalRouter: new (maxQueueSize: number) => SignalRouterInstance;
     EvalPipeline: new (options?: {
         extractSkillOnPass?: boolean;

package/dist/kernel.js

@@ -5,7 +5,7 @@ import { fileURLToPath } from "node:url";
 const cjsRequire = createRequire(import.meta.url);
 let cachedKernel;
 function resolveCoreModule() {
-    const localCore = join(dirname(fileURLToPath(import.meta.url)), "../../../crates/deepstrike-node");
+    const localCore = join(dirname(fileURLToPath(import.meta.url)), "../../crates/deepstrike-node");
     if (existsSync(join(localCore, "index.js")))
         return localCore;
     return "@deepstrike/core";

package/dist/providers/anthropic.js

@@ -3,11 +3,14 @@ import { assistantReplayKey } from "../runtime/provider-replay.js";
 import { withServerRuntimeGuard } from "../runtime/server.js";
 import { CircuitBreaker, normalizeToolCall, omitExtensionKeys, toAnthropicMessages } from "./base.js";
 const CLAUDE_POLICIES = {
+    "claude-opus-4-1": { maxTurns: 50 },
     "claude-opus-4-7": { maxTurns: 50 },
     "claude-opus-4-6": { maxTurns: 50 },
+    "claude-opus-4-0": { maxTurns: 50 },
     "claude-sonnet-4-6": { maxTurns: 25 },
+    "claude-sonnet-4-0": { maxTurns: 25 },
     "claude-haiku-4-5": { maxTurns: 15 },
-    "claude-haiku-4-5-20251001": { maxTurns: 15 },
+    "claude-3-5-haiku-latest": { maxTurns: 15 },
 };
 export class AnthropicProvider {
     model;
@@ -19,7 +22,9 @@ export class AnthropicProvider {
     constructor(apiKey, model = "claude-sonnet-4-6", retry = { maxRetries: 3, baseDelay: 1000 }, options = {}) {
         this.model = model;
         this.client = withServerRuntimeGuard(() => new Anthropic({
-            ...(options.authMode === "bearer" ? { authToken: apiKey } : { apiKey }),
+            ...(options.authMode === "bearer"
+                ? { authToken: apiKey, apiKey: null }
+                : { apiKey, authToken: null }),
             ...(options.baseURL ? { baseURL: options.baseURL } : {}),
         }));
         this.circuit = new CircuitBreaker();

package/dist/providers/base.d.ts

@@ -23,3 +23,15 @@ export declare function toOpenAIContent(msg: Message): string | Array<Record<str
 /** Build the full OpenAI messages array from a RenderedContext.
  *  Prepends systemText as the first system message, then converts turns. */
 export declare function toOpenAIMessageParams(context: RenderedContext): Array<Record<string, unknown>>;
+export declare class ThinkingTagStreamExtractor {
+    private buffer;
+    private inThinking;
+    feed(chunk: string): Array<{
+        type: "text" | "thinking";
+        content: string;
+    }>;
+    flush(): Array<{
+        type: "text" | "thinking";
+        content: string;
+    }>;
+}

package/dist/providers/base.js

@@ -166,3 +166,78 @@ export function toOpenAIMessageParams(context) {
     }
     return result;
 }
+export class ThinkingTagStreamExtractor {
+    buffer = "";
+    inThinking = false;
+    feed(chunk) {
+        this.buffer += chunk;
+        const events = [];
+        while (true) {
+            if (!this.inThinking) {
+                const thinkIndex = this.buffer.indexOf("<think>");
+                if (thinkIndex !== -1) {
+                    const textBefore = this.buffer.substring(0, thinkIndex);
+                    if (textBefore) {
+                        events.push({ type: "text", content: textBefore });
+                    }
+                    this.inThinking = true;
+                    this.buffer = this.buffer.substring(thinkIndex + 7);
+                    continue;
+                }
+                const possibleTagStart = this.buffer.lastIndexOf("<");
+                if (possibleTagStart !== -1 && "<think>".startsWith(this.buffer.substring(possibleTagStart))) {
+                    const toEmit = this.buffer.substring(0, possibleTagStart);
+                    if (toEmit) {
+                        events.push({ type: "text", content: toEmit });
+                    }
+                    this.buffer = this.buffer.substring(possibleTagStart);
+                    break;
+                }
+                else {
+                    if (this.buffer) {
+                        events.push({ type: "text", content: this.buffer });
+                        this.buffer = "";
+                    }
+                    break;
+                }
+            }
+            else {
+                const endThinkIndex = this.buffer.indexOf("</think>");
+                if (endThinkIndex !== -1) {
+                    const thinkingContent = this.buffer.substring(0, endThinkIndex);
+                    if (thinkingContent) {
+                        events.push({ type: "thinking", content: thinkingContent });
+                    }
+                    this.inThinking = false;
+                    this.buffer = this.buffer.substring(endThinkIndex + 8);
+                    continue;
+                }
+                const possibleEndStart = this.buffer.lastIndexOf("<");
+                if (possibleEndStart !== -1 && "</think>".startsWith(this.buffer.substring(possibleEndStart))) {
+                    const toEmit = this.buffer.substring(0, possibleEndStart);
+                    if (toEmit) {
+                        events.push({ type: "thinking", content: toEmit });
+                    }
+                    this.buffer = this.buffer.substring(possibleEndStart);
+                    break;
+                }
+                else {
+                    if (this.buffer) {
+                        events.push({ type: "thinking", content: this.buffer });
+                        this.buffer = "";
+                    }
+                    break;
+                }
+            }
+        }
+        return events;
+    }
+    flush() {
+        const events = [];
+        if (this.buffer) {
+            events.push({ type: this.inThinking ? "thinking" : "text", content: this.buffer });
+            this.buffer = "";
+        }
+        return events;
+    }
+}

package/dist/providers/catalog.d.ts

@@ -1,9 +1,10 @@
 import type { LLMProvider } from "../types.js";
-import { endpointProfiles, type ModelProfileId } from "./profiles.js";
+import { endpointProfiles, type ModelProfileId, type ProviderId } from "./profiles.js";
 export type EndpointProfileId = keyof typeof endpointProfiles;
 export interface CreateProviderOptions {
-    model: ModelProfileId;
+    model: ModelProfileId | string;
     apiKey: string;
+    provider?: ProviderId;
     endpoint?: EndpointProfileId;
     retry?: {
         maxRetries: number;