@deepstrike/sdk 0.1.5 → 0.1.8

package/README.md

@@ -16,13 +16,15 @@ Pre-built native addons are available for the following platforms:
 
 | Platform | Package |
 | -------- | ------- |
-| Linux x64 (glibc) | `@deepstrike/core-linux-x64-gnu` |
-| Linux ARM64 (glibc) | `@deepstrike/core-linux-arm64-gnu` |
 | macOS x64 | `@deepstrike/core-darwin-x64` |
 | macOS ARM64 (Apple Silicon) | `@deepstrike/core-darwin-arm64` |
+| Linux x64 (glibc) | `@deepstrike/core-linux-x64-gnu` |
+| Linux x64 (musl / Alpine) | `@deepstrike/core-linux-x64-musl` |
+| Linux ARM64 (glibc) | `@deepstrike/core-linux-arm64-gnu` |
+| Linux ARM64 (musl / Alpine) | `@deepstrike/core-linux-arm64-musl` |
 | Windows x64 | `@deepstrike/core-win32-x64-msvc` |
 
-The correct platform package is selected and installed automatically via `optionalDependencies`.
+The correct platform package is selected and installed automatically via `optionalDependencies`. No postinstall download is required.
 
 > **Note:** `@deepstrike/core` is the low-level native addon package and is not intended for direct use. It is an internal dependency automatically managed by `@deepstrike/sdk`. Direct installation is only relevant when building from Rust source.
 
@@ -31,13 +33,9 @@ The correct platform package is selected and installed automatically via `option
 ## Quick start
 
 ```typescript
-import { Agent, OpenAIProvider, tool } from "@deepstrike/sdk"
+import { Agent, OpenAIResponsesProvider, tool } from "@deepstrike/sdk"
 
-const provider = new OpenAIProvider({
-  apiKey: process.env.OPENAI_API_KEY,
-  model: "gpt-5-mini",
-  baseUrl: "https://api.openai.com/v1",
-})
+const provider = new OpenAIResponsesProvider(process.env.OPENAI_API_KEY!, "gpt-5-mini")
 
 const add = tool("add", "Add two numbers.", {
   type: "object",
@@ -49,7 +47,7 @@ const agent = new Agent(provider, { maxTokens: 4096 })
 agent.register(add)
 
 const result = await agent.run("What is 17 + 28?")
-console.log(result) // "done in 2 turns (completed)"
+console.log(result)
 ```
 
 Streaming:
@@ -69,16 +67,29 @@ for await (const event of agent.runStreaming("Summarize README.md")) {
 
 | Class | Backend | Notes |
 |-------|---------|-------|
-| `OpenAIProvider` | OpenAI API | SSE tool-call accumulation |
+| `OpenAIChatProvider` | OpenAI Chat Completions API | SSE tool-call accumulation |
+| `OpenAIProvider` | OpenAI Chat Completions API | Compatibility alias for `OpenAIChatProvider` |
+| `OpenAIResponsesProvider` | OpenAI Responses API | Native `previous_response_id` continuation |
 | `AnthropicProvider` | Anthropic API | Native SSE, `ThinkingDelta` support |
 | `QwenProvider` | DashScope | `enable_thinking` via extensions |
-| `DeepSeekProvider` | DeepSeek API | Reasoner models strip tools automatically |
-| `MiniMaxProvider` | MiniMax API | M1 reasoning via `expose_reasoning` |
+| `DeepSeekProvider` | DeepSeek API | V4 thinking controls + reasoning replay across tool turns |
+| `MiniMaxProvider` | MiniMax API | Anthropic-compatible M2.7/M2.5 path |
 | `OllamaProvider` | Local Ollama | `http://localhost:11434` default |
-| `KimiProvider` | Moonshot API | |
+| `KimiProvider` | Moonshot API | K2.6 default; K2.5 also supported |
 
 All providers accept `RetryConfig` for exponential backoff and share a `CircuitBreaker`.
 
+OpenAI can also be selected through the provider catalog:
+
+```typescript
+import { createProvider } from "@deepstrike/sdk"
+
+const provider = createProvider({
+  model: "openai/gpt-5-mini",
+  apiKey: process.env.OPENAI_API_KEY!,
+})
+```
+
 ---
 
 ## Agent options
@@ -106,9 +117,8 @@ const agent = new Agent(provider, {
 import { tool, readFile } from "@deepstrike/sdk"
 
 agent.register(tool("search", "Search.", schema, async (args) => ...))
-agent.register(readFile())   // built-in: read files from disk
+agent.register(readFile)     // built-in: read files from disk
 agent.unregister("search")
-agent.blockTool("bash")      // governance veto
 ```
 
 ---
@@ -211,6 +221,9 @@ const gov = new Governance("allow")
 gov.addPermissionRule("danger.*", "deny")
 gov.blockTool("rm_rf")
 gov.setRateLimit("api_call", 10, 60_000)
+gov.requireParam("write_file", "path")
+gov.allowParamValues("set_mode", "mode", ["read", "write"])
+gov.limitParamRange("sleep", "seconds", 0, 10)
 
 const agent = new Agent(provider, { maxTokens: 4096, governance: gov })
 // Every tool call goes through: Permission → Veto → RateLimit → Constraint → Audit
@@ -224,12 +237,10 @@ const agent = new Agent(provider, { maxTokens: 4096, governance: gov })
 import { SignalGateway, ScheduledPrompt } from "@deepstrike/sdk"
 
 const gw = new SignalGateway()
-const rx = gw.subscribe()
-
 gw.schedule(new ScheduledPrompt("standup", Date.now() + 3600_000))
-gw.ingest({ kind: "interrupt", payload: {}, priority: 10 })
+gw.ingest({ kind: "interrupt", urgency: "critical", payload: {} })
 
-const agent = new Agent(provider, { maxTokens: 4096, signalSource: rx })
+const agent = new Agent(provider, { maxTokens: 4096, signalSource: gw })
 // kind="interrupt" → immediately stops the running agent
 
 agent.interrupt() // also works directly

package/dist/agent.d.ts

@@ -34,11 +34,12 @@ export interface AgentOptions {
      */
     agentId?: string;
     /**
-     * Kernel Governance instance (from `@deepstrike/core`) or any object implementing
+     * SDK Governance instance or any object implementing
      * `evaluate(toolName: string, argsJson: string): { kind: string; reason?: string; retryAfterMs?: number }`.
      * When provided, every tool call is evaluated through the full pipeline.
      */
     governance?: {
+        setTime?(nowMs: bigint): void;
         evaluate(toolName: string, argsJson: string): {
             kind: string;
             reason?: string;

package/dist/agent.js

@@ -1,12 +1,6 @@
 import { executeTools } from "./tools/index.js";
 import { readSkillFile, scanSkillDir } from "./skills/loader.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function loadKernel() {
-    const mod = await import("@deepstrike/core");
-    // CJS modules imported via ESM dynamic import expose exports under `.default`
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return mod.default ?? mod;
-}
+import { getKernel } from "./kernel.js";
 export class Agent {
     provider;
     options;
@@ -66,12 +60,13 @@ export class Agent {
         if (this.knowledgeSource) {
             await this.knowledgeSource.init();
         }
-        const kernel = await loadKernel();
+        const kernel = getKernel();
         const ext = { ...this.extensions, ...(extensions ?? {}) };
+        const providerState = this.provider.createRunState?.();
         const sm = new kernel.LoopStateMachine({
             maxTokens: this.options.maxTokens,
             maxTurns: this.options.maxTurns ?? 25,
-            timeoutMs: this.options.timeoutMs,
+            timeoutMs: this.options.timeoutMs === undefined ? undefined : BigInt(this.options.timeoutMs),
         });
         // Per-run SignalRouter — dedup state never leaks between runs.
         const router = new kernel.SignalRouter(256);
@@ -123,16 +118,14 @@ export class Agent {
             if (this.signalSource) {
                 const sig = await this.signalSource.nextSignal();
                 if (sig) {
-                    const sigAny = sig;
                     const kernelSig = {
                         id: crypto.randomUUID(),
-                        source: sigAny.source ?? "custom",
-                        signalType: sigAny.signalType ?? "event",
-                        urgency: sigAny.urgency
-                            ?? (sig.kind === "interrupt" ? "critical" : "normal"),
-                        summary: String(sig.payload?.goal ?? sig.kind),
+                        source: sig.source ?? "custom",
+                        signalType: sig.signalType ?? "event",
+                        urgency: normalizeSignalUrgency(sig),
+                        summary: String(sig.payload?.goal ?? sig.kind ?? "signal"),
                         payload: JSON.stringify(sig.payload ?? {}),
-                        dedupeKey: sigAny.dedupeKey ?? null,
+                        dedupeKey: sig.dedupeKey,
                         timestampMs: Date.now(),
                     };
                     const disposition = router.ingest(kernelSig, action.kind === "execute_tools");
@@ -164,7 +157,7 @@ export class Agent {
                 const tools = (action.tools ?? []);
                 let turnTokens = 0;
                 try {
-                    for await (const evt of this.provider.stream(messages, tools, Object.keys(ext).length ? ext : undefined)) {
+                    for await (const evt of this.provider.stream(messages, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
                         if (evt.type === "usage") {
                             turnTokens = evt.totalTokens;
                             continue;
@@ -193,6 +186,7 @@ export class Agent {
                 const deniedResults = [];
                 for (const c of allCalls) {
                     if (this.options.governance) {
+                        this.options.governance.setTime?.(BigInt(Date.now()));
                         const verdict = this.options.governance.evaluate(c.name, c.arguments);
                         if (verdict.kind === "deny") {
                             const msg = `permission denied: ${c.name} — ${verdict.reason ?? ""}`;
@@ -270,7 +264,7 @@ export class Agent {
         const result = action.result;
         this._turn = sm.turn;
         this._pressure = sm.pressure();
-        const status = result?.termination === "completed" ? "success" : (result?.termination ?? "error");
+        const status = result?.termination ?? "error";
         const iterations = result ? Math.max(1, result.turnsUsed) : 0;
         if (this.options.dreamStore && this.options.agentId && sessionMsgs.length > 1) {
             try {
@@ -304,7 +298,7 @@ export class Agent {
     async dream(agentId, nowMs = Date.now()) {
         if (!this.dreamStore)
             throw new Error("dreamStore not configured on AgentOptions");
-        const kernel = await loadKernel();
+        const kernel = getKernel();
         const sessions = await this.dreamStore.loadSessions(agentId);
         const existingMemories = await this.dreamStore.loadMemories(agentId);
         if (!sessions.length) {
@@ -337,7 +331,8 @@ export class Agent {
             throw new Error(`unexpected action after feedTrigger: ${action1.kind}`);
         }
         let synthesisText = "";
-        for await (const evt of this.provider.stream((action1.messages ?? []), [], undefined)) {
+        const providerState = this.provider.createRunState?.();
+        for await (const evt of this.provider.stream((action1.messages ?? []), [], undefined, providerState)) {
             if (evt.type === "text_delta")
                 synthesisText += evt.delta;
         }
@@ -378,3 +373,6 @@ function tryParseJson(s) {
         return null;
     }
 }
+function normalizeSignalUrgency(sig) {
+    return sig.urgency;
+}

package/dist/governance.d.ts

@@ -0,0 +1,17 @@
+import type { GovernanceVerdict } from "./kernel.js";
+type GovernanceDefaultAction = "allow" | "deny" | "ask_user";
+type GovernanceRuleAction = "allow" | "deny" | "ask_user";
+export declare class Governance {
+    private readonly inner;
+    constructor(defaultAction?: GovernanceDefaultAction);
+    setIdentity(agentId: string, sessionId: string): void;
+    addPermissionRule(pattern: string, action: GovernanceRuleAction): void;
+    blockTool(name: string): void;
+    setRateLimit(toolName: string, maxCalls: number, windowMs: number): void;
+    requireParam(toolName: string, paramPath: string): void;
+    allowParamValues(toolName: string, paramPath: string, allowedValues: string[]): void;
+    limitParamRange(toolName: string, paramPath: string, min?: number, max?: number): void;
+    setTime(nowMs: number | bigint): void;
+    evaluate(toolName: string, argsJson: string): GovernanceVerdict;
+}
+export type { GovernanceVerdict };

package/dist/governance.js

@@ -0,0 +1,34 @@
+import { getKernel } from "./kernel.js";
+export class Governance {
+    inner;
+    constructor(defaultAction = "allow") {
+        this.inner = new (getKernel().Governance)(defaultAction);
+    }
+    setIdentity(agentId, sessionId) {
+        this.inner.setIdentity(agentId, sessionId);
+    }
+    addPermissionRule(pattern, action) {
+        this.inner.addPermissionRule(pattern, action);
+    }
+    blockTool(name) {
+        this.inner.blockTool(name);
+    }
+    setRateLimit(toolName, maxCalls, windowMs) {
+        this.inner.setRateLimit(toolName, maxCalls, BigInt(windowMs));
+    }
+    requireParam(toolName, paramPath) {
+        this.inner.requireParam(toolName, paramPath);
+    }
+    allowParamValues(toolName, paramPath, allowedValues) {
+        this.inner.allowParamValues(toolName, paramPath, allowedValues);
+    }
+    limitParamRange(toolName, paramPath, min, max) {
+        this.inner.limitParamRange(toolName, paramPath, min, max);
+    }
+    setTime(nowMs) {
+        this.inner.setTime(typeof nowMs === "bigint" ? nowMs : BigInt(nowMs));
+    }
+    evaluate(toolName, argsJson) {
+        return this.inner.evaluate(toolName, argsJson);
+    }
+}

package/dist/harness/harness.js

@@ -1,11 +1,6 @@
 import { writeFile } from "fs/promises";
 import path from "path";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function loadKernel() {
-    const mod = await import("@deepstrike/core");
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return mod.default ?? mod;
-}
+import { getKernel } from "../kernel.js";
 async function runOnce(agent, req) {
     let text = "";
     let done;
@@ -57,7 +52,7 @@ export class HarnessLoop {
         this.skillDir = options.skillDir;
     }
     async *runStreaming(request) {
-        const kernel = await loadKernel();
+        const kernel = getKernel();
         const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
         const criteria = request.criteria ?? [];
         // history tracks the full conversation; agent sees only the current goal message
@@ -111,8 +106,8 @@ export class HarnessLoop {
                 details: doneAction.details ?? [],
             };
             if (verdict.passed) {
-                if (doneAction.skill_candidate && this.skillDir) {
-                    const { name, description, whenToUse, content } = doneAction.skill_candidate;
+                if (doneAction.skillCandidate && this.skillDir) {
+                    const { name, description, whenToUse, content } = doneAction.skillCandidate;
                     const fm = ["---", `name: ${name}`, `description: ${description}`,
                         whenToUse ? `when_to_use: ${whenToUse}` : null, "---", ""]
                         .filter(Boolean).join("\n");

package/dist/index.d.ts

@@ -1,9 +1,20 @@
 export { Agent } from "./agent.js";
 export type { AgentOptions } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
+export { OpenAIChatProvider, OpenAIProvider } from "./providers/openai.js";
+export { DeepSeekProvider } from "./providers/deepseek.js";
+export { KimiProvider } from "./providers/kimi.js";
+export { QwenProvider } from "./providers/qwen.js";
+export { GeminiProvider } from "./providers/gemini.js";
+export { MiniMaxProvider } from "./providers/minimax.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
+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 { createProvider } from "./providers/catalog.js";
+export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
 export { tool, executeTools, readFile } from "./tools/index.js";
 export type { RegisteredTool } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
@@ -18,6 +29,6 @@ export { SignalGateway } from "./signals/gateway.js";
 export type { RuntimeSignal, SignalSource } from "./signals/types.js";
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export type { PermissionDecision, Permission } from "./safety/permissions.js";
-export declare const Governance: typeof import("@deepstrike/core").Governance;
-export type { GovernanceVerdictObj as GovernanceVerdict } from "@deepstrike/core";
-export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, } from "./types.js";
+export { Governance } from "./governance.js";
+export type { GovernanceVerdict } from "./governance.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, } from "./types.js";

package/dist/index.js

@@ -1,8 +1,17 @@
 export { Agent } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
+export { OpenAIChatProvider, OpenAIProvider } from "./providers/openai.js";
+export { DeepSeekProvider } from "./providers/deepseek.js";
+export { KimiProvider } from "./providers/kimi.js";
+export { QwenProvider } from "./providers/qwen.js";
+export { GeminiProvider } from "./providers/gemini.js";
+export { MiniMaxProvider } from "./providers/minimax.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
+export { OpenAIChatAdapter } from "./providers/openai-chat.js";
+export { OpenAIResponsesAdapter, OpenAIResponsesProvider } from "./providers/openai-responses.js";
+export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
+export { createProvider } from "./providers/catalog.js";
 export { tool, executeTools, readFile } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
 export { WorkingMemory } from "./memory/working.js";
@@ -10,10 +19,4 @@ export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harne
 export { ScheduledPrompt } from "./signals/scheduled.js";
 export { SignalGateway } from "./signals/gateway.js";
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
-// Kernel Governance — full pipeline (Permission → Veto → RateLimit → Constraint → Audit)
-// @deepstrike/core is a CJS native addon; static ESM named re-export doesn't work,
-// so we load it via createRequire and re-export with proper types preserved.
-import { createRequire } from "module";
-const _cjsRequire = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const Governance = _cjsRequire("@deepstrike/core").Governance;
+export { Governance } from "./governance.js";

package/dist/kernel.d.ts

@@ -0,0 +1,149 @@
+import type { Message, ToolCall, ToolResult, ToolSchema } from "./types.js";
+import type { SkillMetadata } from "./skills/loader.js";
+export interface GovernanceVerdict {
+    kind: "allow" | "deny" | "rate_limited" | "ask_user";
+    reason?: string;
+    retryAfterMs?: number;
+}
+export interface GovernanceInstance {
+    setIdentity(agentId: string, sessionId: string): void;
+    addPermissionRule(pattern: string, action: "allow" | "deny" | "ask_user"): void;
+    blockTool(name: string): void;
+    setRateLimit(toolName: string, maxCalls: number, windowMs: bigint): void;
+    requireParam(toolName: string, paramPath: string): void;
+    allowParamValues(toolName: string, paramPath: string, allowedValues: string[]): void;
+    limitParamRange(toolName: string, paramPath: string, min?: number, max?: number): void;
+    setTime(nowMs: bigint): void;
+    evaluate(toolName: string, argsJson: string): GovernanceVerdict;
+}
+export interface RuntimeSignal {
+    id: string;
+    source: "cron" | "gateway" | "heartbeat" | "custom";
+    signalType: "event" | "job" | "alert";
+    urgency: "low" | "normal" | "high" | "critical";
+    summary: string;
+    payload: string;
+    dedupeKey?: string;
+    timestampMs: number;
+}
+export interface LoopAction {
+    kind: "call_llm" | "execute_tools" | "done";
+    messages?: Message[];
+    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;
+    setTools(tools: ToolSchema[]): void;
+    start(task: {
+        goal: string;
+        criteria: string[];
+    }): LoopAction;
+    feedLlmResponse(message: Message): LoopAction;
+    feedToolResults(results: ToolResult[]): LoopAction;
+    feedTimeout(): LoopAction;
+    isTerminal(): boolean;
+    readonly turn: number;
+    pressure(): number;
+    takeObservations(): LoopObservation[];
+}
+interface SignalRouterInstance {
+    ingest(signal: RuntimeSignal, isRunning: boolean): string;
+    next(): RuntimeSignal | null;
+}
+interface NativeCriterion {
+    text: string;
+    required: boolean;
+    weight?: number;
+}
+interface EvalPipelineAction {
+    kind: "evaluate" | "done";
+    messages?: Message[];
+    passed?: boolean;
+    overallScore?: number;
+    feedback?: string;
+    details?: Array<{
+        criterion: string;
+        passed: boolean;
+        score: number;
+        feedback: string;
+    }>;
+    skillCandidate?: {
+        name: string;
+        description: string;
+        whenToUse?: string;
+        content: string;
+    };
+}
+interface EvalPipelineInstance {
+    feedOutcome(goal: string, criteria: NativeCriterion[], result: string, attempt: number): EvalPipelineAction;
+    feedEvalResult(content: string): EvalPipelineAction;
+    reset(): void;
+}
+interface IdlePipelineAction {
+    kind: "synthesize_insights" | "commit_memories" | "noop" | "aborted";
+    messages?: Message[];
+    curationResult?: {
+        toAdd?: Array<{
+            text: string;
+            score: number;
+            metadata: string;
+        }>;
+        toRemoveIndices?: number[];
+        stats?: {
+            insightsProcessed?: number;
+            duplicatesRemoved?: number;
+            conflictsResolved?: number;
+            entriesAdded?: number;
+        };
+    };
+    runResult?: {
+        sessionsProcessed: number;
+        insightsExtracted: number;
+    };
+}
+interface IdlePipelineInstance {
+    feedTrigger(sessions: Array<{
+        sessionId: string;
+        agentId: string;
+        messages: Message[];
+        metadata: string;
+        createdAtMs: number;
+        updatedAtMs: number;
+    }>, existingMemories: Array<{
+        text: string;
+        score: number;
+        metadata: string;
+    }>, nowMs: number): IdlePipelineAction;
+    feedSynthesisResult(content: string): IdlePipelineAction;
+}
+interface KernelModule {
+    Governance: new (defaultAction?: "allow" | "deny" | "ask_user") => GovernanceInstance;
+    LoopStateMachine: new (policy: {
+        maxTokens: number;
+        maxTurns?: number;
+        maxTotalTokens?: bigint;
+        timeoutMs?: bigint;
+    }) => LoopStateMachineInstance;
+    SignalRouter: new (maxQueueSize: number) => SignalRouterInstance;
+    EvalPipeline: new (options?: {
+        extractSkillOnPass?: boolean;
+    }) => EvalPipelineInstance;
+    IdlePipeline: new (agentId: string) => IdlePipelineInstance;
+}
+export declare function getKernel(): KernelModule;
+export {};

package/dist/kernel.js

@@ -0,0 +1,9 @@
+import { createRequire } from "module";
+const cjsRequire = createRequire(import.meta.url);
+let cachedKernel;
+export function getKernel() {
+    if (!cachedKernel) {
+        cachedKernel = cjsRequire("@deepstrike/core");
+    }
+    return cachedKernel;
+}

package/dist/memory/protocols.d.ts

@@ -1,5 +1,6 @@
+import type { Message } from "../types.js";
 export interface SessionMessage {
-    role: string;
+    role: Message["role"];
     content: string;
     tokenCount?: number;
     toolCalls?: Array<{

package/dist/memory/protocols.js

@@ -1,2 +1 @@
-// ─── Dream / idle-pipeline types ─────────────────────────────────────────────
 export {};

package/dist/providers/anthropic.d.ts

@@ -1,15 +1,24 @@
 import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+interface AnthropicProviderOptions {
+    baseURL?: string;
+    authMode?: "api-key" | "bearer";
+}
 export declare class AnthropicProvider implements LLMProvider {
-    private readonly model;
+    protected readonly model: string;
     private client;
     private circuit;
     private maxRetries;
     private baseDelay;
+    private nativeAssistantBlocks;
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
-    });
+    }, options?: AnthropicProviderOptions);
     private buildTools;
     complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
     stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    private buildMessages;
+    private rememberNativeBlocks;
+    private assistantReplayKey;
 }
+export {};