@deepstrike/sdk 0.1.1

package/dist/providers/openai.js

@@ -0,0 +1,144 @@
+import OpenAI from "openai";
+import { CircuitBreaker, normalizeToolCall } from "./base.js";
+export class OpenAIProvider {
+    model;
+    client;
+    circuit;
+    maxRetries;
+    baseDelay;
+    constructor(apiKey, model = "gpt-4o", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = "https://api.openai.com/v1") {
+        this.model = model;
+        this.client = new OpenAI({ apiKey, baseURL });
+        this.circuit = new CircuitBreaker();
+        this.maxRetries = retry.maxRetries;
+        this.baseDelay = retry.baseDelay;
+    }
+    buildTools(tools) {
+        return tools.map(t => ({
+            type: "function",
+            function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) },
+        }));
+    }
+    async complete(messages, tools) {
+        if (this.circuit.isOpen())
+            throw new Error("Circuit breaker open");
+        const msgs = messages.map(m => ({ role: m.role, content: m.content }));
+        let lastErr;
+        for (let i = 0; i < this.maxRetries; i++) {
+            try {
+                const resp = await this.client.chat.completions.create({
+                    model: this.model,
+                    messages: msgs,
+                    ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+                });
+                this.circuit.recordSuccess();
+                const choice = resp.choices[0].message;
+                const toolCalls = (choice.tool_calls ?? []).map(tc => normalizeToolCall(tc.id, tc.function.name, tc.function.arguments)).filter(Boolean);
+                return { role: "assistant", content: choice.content ?? "", tokenCount: resp.usage?.total_tokens, toolCalls };
+            }
+            catch (err) {
+                lastErr = err;
+                this.circuit.recordFailure();
+                if (i < this.maxRetries - 1)
+                    await new Promise(r => setTimeout(r, this.baseDelay * 2 ** i));
+            }
+        }
+        throw lastErr;
+    }
+    async *stream(messages, tools, extensions) {
+        const msgs = messages.map(m => ({ role: m.role, content: m.content }));
+        const toolCallBufs = {};
+        const stream = await this.client.chat.completions.create({
+            model: this.model,
+            messages: msgs,
+            ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            const choice = chunk.choices[0];
+            if (!choice)
+                continue;
+            const delta = choice.delta;
+            if (delta.content)
+                yield { type: "text_delta", delta: delta.content };
+            for (const tc of delta.tool_calls ?? []) {
+                const idx = tc.index;
+                if (!toolCallBufs[idx])
+                    toolCallBufs[idx] = { id: tc.id ?? "", name: "", argsBuf: "" };
+                if (tc.function?.name)
+                    toolCallBufs[idx].name += tc.function.name;
+                toolCallBufs[idx].argsBuf += tc.function?.arguments ?? "";
+            }
+            if (choice.finish_reason === "tool_calls") {
+                for (const tb of Object.values(toolCallBufs)) {
+                    let args = {};
+                    try {
+                        args = JSON.parse(tb.argsBuf || "{}");
+                    }
+                    catch {
+                        args = {};
+                    }
+                    yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+                }
+            }
+        }
+    }
+}
+const DASHSCOPE_BASE = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+const DEEPSEEK_BASE = "https://api.deepseek.com/v1";
+const MINIMAX_BASE = "https://api.minimax.chat/v1";
+const DEEPSEEK_REASONERS = new Set(["deepseek-reasoner", "deepseek-r1"]);
+const MINIMAX_REASONERS = new Set(["MiniMax-M1", "minimax-m1"]);
+export class QwenProvider extends OpenAIProvider {
+    constructor(apiKey, model = "qwen-plus", retry) {
+        super(apiKey, model, retry, DASHSCOPE_BASE);
+    }
+}
+export class DeepSeekProvider extends OpenAIProvider {
+    constructor(apiKey, model = "deepseek-chat", retry) {
+        super(apiKey, model, retry, DEEPSEEK_BASE);
+    }
+    async *stream(messages, tools, extensions) {
+        const exposeReasoning = extensions?.exposeReasoning ?? false;
+        const msgs = messages.map(m => ({ role: m.role, content: m.content }));
+        const isReasoner = DEEPSEEK_REASONERS.has(this.model);
+        const stream = await this.client.chat.completions.create({
+            model: this.model,
+            messages: msgs,
+            ...(!isReasoner && tools.length ? { tools: this.buildTools(tools) } : {}),
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (exposeReasoning && delta.reasoning_content) {
+                yield { type: "thinking_delta", delta: delta.reasoning_content };
+            }
+            if (delta.content)
+                yield { type: "text_delta", delta: delta.content };
+        }
+    }
+}
+export class MiniMaxProvider extends OpenAIProvider {
+    constructor(apiKey, model = "MiniMax-Text-01", retry) {
+        super(apiKey, model, retry, MINIMAX_BASE);
+    }
+    async *stream(messages, tools, extensions) {
+        const exposeReasoning = extensions?.exposeReasoning ?? false;
+        const msgs = messages.map(m => ({ role: m.role, content: m.content }));
+        const isReasoner = MINIMAX_REASONERS.has(this.model);
+        const stream = await this.client.chat.completions.create({
+            model: this.model,
+            messages: msgs,
+            ...(!isReasoner && tools.length ? { tools: this.buildTools(tools) } : {}),
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (exposeReasoning && delta.reasoning_content) {
+                yield { type: "thinking_delta", delta: delta.reasoning_content };
+            }
+            if (delta.content)
+                yield { type: "text_delta", delta: delta.content };
+        }
+    }
+}

package/dist/safety/permissions.d.ts

@@ -0,0 +1,17 @@
+export declare enum PermissionMode {
+    DEFAULT = "DEFAULT",
+    PLAN = "PLAN",
+    AUTO = "AUTO"
+}
+export interface PermissionDecision {
+    allowed: boolean;
+    reason: string;
+}
+export declare class PermissionManager {
+    private mode;
+    private grants;
+    constructor(mode?: PermissionMode);
+    grant(resource: string, action: string): this;
+    revoke(resource: string, action: string): this;
+    evaluate(resource: string, action: string): PermissionDecision;
+}

package/dist/safety/permissions.js

@@ -0,0 +1,32 @@
+export var PermissionMode;
+(function (PermissionMode) {
+    PermissionMode["DEFAULT"] = "DEFAULT";
+    PermissionMode["PLAN"] = "PLAN";
+    PermissionMode["AUTO"] = "AUTO";
+})(PermissionMode || (PermissionMode = {}));
+export class PermissionManager {
+    mode;
+    grants = new Map();
+    constructor(mode = PermissionMode.DEFAULT) {
+        this.mode = mode;
+    }
+    grant(resource, action) {
+        if (!this.grants.has(resource))
+            this.grants.set(resource, new Set());
+        this.grants.get(resource).add(action);
+        return this;
+    }
+    revoke(resource, action) {
+        this.grants.get(resource)?.delete(action);
+        return this;
+    }
+    evaluate(resource, action) {
+        if (this.mode === PermissionMode.AUTO)
+            return { allowed: true, reason: "AUTO mode" };
+        if (this.mode === PermissionMode.PLAN)
+            return { allowed: false, reason: "PLAN mode blocks all" };
+        const actions = this.grants.get(resource);
+        const allowed = !!(actions && (actions.has(action) || actions.has("*")));
+        return { allowed, reason: allowed ? "granted" : "not granted" };
+    }
+}

package/dist/signals/gateway.d.ts

@@ -0,0 +1,30 @@
+import type { RuntimeSignal } from "./types.js";
+import type { ScheduledPrompt } from "./scheduled.js";
+/**
+ * SignalGateway — the entry point for all external signals into the agent.
+ *
+ * Responsibilities:
+ * - Cron scheduling: fires ScheduledPrompts at the right time (deduplicated)
+ * - Webhook ingestion: converts raw external payloads to RuntimeSignal
+ * - Routes all signals through the kernel SignalRouter for priority + dedup
+ *
+ * Usage:
+ *   const gateway = new SignalGateway()
+ *   gateway.schedule(new ScheduledPrompt("summarize", Date.now() + 60_000))
+ *   gateway.onSignal(sig => agent.ingestSignal(sig))
+ */
+export declare class SignalGateway {
+    private timers;
+    private listeners;
+    private router;
+    init(): Promise<void>;
+    onSignal(listener: (sig: RuntimeSignal) => void): void;
+    /** Schedule a ScheduledPrompt to fire at its runAtMs. Idempotent by goal. */
+    schedule(prompt: ScheduledPrompt): void;
+    /** Cancel a scheduled prompt. */
+    cancel(goal: string, runAtMs: number): void;
+    /** Ingest a raw external signal (e.g. from a webhook handler). */
+    ingest(sig: RuntimeSignal): void;
+    private emit;
+    destroy(): void;
+}

package/dist/signals/gateway.js

@@ -0,0 +1,71 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function loadKernel() {
+    return import("@deepstrike/core");
+}
+/**
+ * SignalGateway — the entry point for all external signals into the agent.
+ *
+ * Responsibilities:
+ * - Cron scheduling: fires ScheduledPrompts at the right time (deduplicated)
+ * - Webhook ingestion: converts raw external payloads to RuntimeSignal
+ * - Routes all signals through the kernel SignalRouter for priority + dedup
+ *
+ * Usage:
+ *   const gateway = new SignalGateway()
+ *   gateway.schedule(new ScheduledPrompt("summarize", Date.now() + 60_000))
+ *   gateway.onSignal(sig => agent.ingestSignal(sig))
+ */
+export class SignalGateway {
+    timers = new Map();
+    listeners = [];
+    router = null;
+    async init() {
+        const kernel = await loadKernel();
+        this.router = new kernel.SignalRouter(1024);
+    }
+    onSignal(listener) {
+        this.listeners.push(listener);
+    }
+    /** Schedule a ScheduledPrompt to fire at its runAtMs. Idempotent by goal. */
+    schedule(prompt) {
+        const key = `cron:${prompt.goal}:${prompt.runAtMs}`;
+        if (this.timers.has(key))
+            return; // already scheduled
+        const delay = prompt.runAtMs - Date.now();
+        const fire = () => {
+            this.timers.delete(key);
+            this.emit({
+                kind: "scheduled",
+                payload: { goal: prompt.goal, criteria: prompt.criteria, runAtMs: prompt.runAtMs, ...prompt.metadata },
+            });
+        };
+        if (delay <= 0) {
+            fire();
+        }
+        else {
+            this.timers.set(key, setTimeout(fire, delay));
+        }
+    }
+    /** Cancel a scheduled prompt. */
+    cancel(goal, runAtMs) {
+        const key = `cron:${goal}:${runAtMs}`;
+        const t = this.timers.get(key);
+        if (t) {
+            clearTimeout(t);
+            this.timers.delete(key);
+        }
+    }
+    /** Ingest a raw external signal (e.g. from a webhook handler). */
+    ingest(sig) {
+        this.emit(sig);
+    }
+    emit(sig) {
+        for (const l of this.listeners)
+            l(sig);
+    }
+    destroy() {
+        for (const t of this.timers.values())
+            clearTimeout(t);
+        this.timers.clear();
+    }
+}

package/dist/signals/scheduled.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeSignal } from "./types.js";
+export declare class ScheduledPrompt {
+    readonly goal: string;
+    readonly runAtMs: number;
+    readonly criteria: string[];
+    readonly metadata: Record<string, unknown>;
+    constructor(goal: string, runAtMs: number, criteria?: string[], metadata?: Record<string, unknown>);
+    toSignal(): RuntimeSignal;
+}

package/dist/signals/scheduled.js

@@ -0,0 +1,18 @@
+export class ScheduledPrompt {
+    goal;
+    runAtMs;
+    criteria;
+    metadata;
+    constructor(goal, runAtMs, criteria = [], metadata = {}) {
+        this.goal = goal;
+        this.runAtMs = runAtMs;
+        this.criteria = criteria;
+        this.metadata = metadata;
+    }
+    toSignal() {
+        return {
+            kind: "scheduled",
+            payload: { goal: this.goal, criteria: this.criteria, runAtMs: this.runAtMs, ...this.metadata },
+        };
+    }
+}

package/dist/signals/types.d.ts

@@ -0,0 +1,8 @@
+export interface RuntimeSignal {
+    kind: "interrupt" | "scheduled" | "external";
+    payload: Record<string, unknown>;
+    priority?: number;
+}
+export interface SignalSource {
+    nextSignal(): Promise<RuntimeSignal | null>;
+}

package/dist/signals/types.js

@@ -0,0 +1 @@
+export {};

package/dist/skills/loader.d.ts

@@ -0,0 +1,11 @@
+export interface SkillMetadata {
+    name: string;
+    description: string;
+    whenToUse?: string;
+    effort?: number;
+    estimatedTokens?: number;
+}
+/** Read one skill file and return its full markdown content. */
+export declare function readSkillFile(skillDir: string, name: string): Promise<string | null>;
+/** Scan a skill directory and return frontmatter-only metadata for all `.md` files. */
+export declare function scanSkillDir(skillDir: string): Promise<SkillMetadata[]>;

package/dist/skills/loader.js

@@ -0,0 +1,43 @@
+import { readFile, readdir } from "fs/promises";
+import path from "path";
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match)
+        return { meta: {}, body: content };
+    const meta = {};
+    for (const line of match[1].split("\n")) {
+        const [k, ...v] = line.split(":");
+        if (k && v.length)
+            meta[k.trim()] = v.join(":").trim();
+    }
+    return { meta, body: match[2] };
+}
+/** Read one skill file and return its full markdown content. */
+export async function readSkillFile(skillDir, name) {
+    try {
+        return await readFile(path.join(skillDir, `${name}.md`), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Scan a skill directory and return frontmatter-only metadata for all `.md` files. */
+export async function scanSkillDir(skillDir) {
+    const files = await readdir(skillDir).catch(() => []);
+    const results = [];
+    for (const file of files.filter(f => f.endsWith(".md"))) {
+        const name = file.slice(0, -3);
+        const content = await readSkillFile(skillDir, name);
+        if (!content)
+            continue;
+        const { meta } = parseFrontmatter(content);
+        results.push({
+            name: meta.name ? String(meta.name) : name,
+            description: meta.description ? String(meta.description) : "",
+            whenToUse: meta.when_to_use ? String(meta.when_to_use) : undefined,
+            effort: meta.effort ? Number(meta.effort) : undefined,
+            estimatedTokens: meta.estimated_tokens ? Number(meta.estimated_tokens) : undefined,
+        });
+    }
+    return results;
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,12 @@
+import type { ToolSchema, ToolResult } from "../types.js";
+export interface RegisteredTool {
+    schema: ToolSchema;
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+export declare function tool(name: string, description: string, parameters: Record<string, unknown>, fn: (args: Record<string, unknown>) => Promise<string> | string): RegisteredTool;
+export declare function executeTools(calls: {
+    id: string;
+    name: string;
+    arguments: string;
+}[], registry: Map<string, RegisteredTool>): Promise<ToolResult[]>;
+export declare const readFile: RegisteredTool;

package/dist/tools/index.js

@@ -0,0 +1,25 @@
+export function tool(name, description, parameters, fn) {
+    return {
+        schema: { name, description, parameters: JSON.stringify(parameters) },
+        async execute(args) { return fn(args); },
+    };
+}
+export async function executeTools(calls, registry) {
+    return Promise.all(calls.map(async (c) => {
+        const t = registry.get(c.name);
+        if (!t)
+            return { callId: c.id, output: `unknown tool: ${c.name}`, isError: true };
+        try {
+            const args = JSON.parse(c.arguments || "{}");
+            const output = await t.execute(args);
+            return { callId: c.id, output, isError: false };
+        }
+        catch (err) {
+            return { callId: c.id, output: String(err), isError: true };
+        }
+    }));
+}
+export const readFile = tool("read_file", "Read the contents of a file.", { type: "object", properties: { path: { type: "string" } }, required: ["path"] }, async ({ path }) => {
+    const { readFile: fsRead } = await import("fs/promises");
+    return fsRead(String(path), "utf8");
+});

package/dist/types.d.ts

@@ -0,0 +1,73 @@
+export interface Message {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    tokenCount?: number;
+    toolCalls?: ToolCall[];
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+export interface ToolResult {
+    callId: string;
+    output: string;
+    isError: boolean;
+    tokenCount?: number;
+}
+export interface ToolSchema {
+    name: string;
+    description: string;
+    parameters: string;
+}
+export interface StreamEvent {
+    type: string;
+}
+export interface TextDelta extends StreamEvent {
+    type: "text_delta";
+    delta: string;
+}
+export interface ThinkingDelta extends StreamEvent {
+    type: "thinking_delta";
+    delta: string;
+}
+export interface ToolCallEvent extends StreamEvent {
+    type: "tool_call";
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface ToolResultEvent extends StreamEvent {
+    type: "tool_result";
+    callId: string;
+    name: string;
+    content: string;
+    isError: boolean;
+}
+export interface DoneEvent extends StreamEvent {
+    type: "done";
+    iterations: number;
+    totalTokens: number;
+    status: string;
+}
+export interface ErrorEvent extends StreamEvent {
+    type: "error";
+    message: string;
+}
+export interface PermissionRequestEvent extends StreamEvent {
+    type: "permission_request";
+    callId: string;
+    toolName: string;
+    arguments: string;
+    reason: string;
+}
+export interface RetryConfig {
+    maxRetries?: number;
+    baseDelay?: number;
+    circuitOpenAfter?: number;
+    circuitResetAfter?: number;
+}
+export interface LLMProvider {
+    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@deepstrike/sdk",
+  "version": "0.1.1",
+  "description": "DeepStrike Node.js SDK",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@deepstrike/core": "0.1.0",
+    "openai": "^4.77.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  }
+}