@deepstrike/sdk 0.1.1 → 0.1.4

package/dist/providers/base.js

@@ -44,3 +44,37 @@ export function normalizeToolCall(id, name, args) {
     }
     return { id: String(id ?? ""), name: n, arguments: JSON.stringify(parsed) };
 }
+export function toAnthropicContent(msg) {
+    if (!msg.contentParts?.length)
+        return msg.content;
+    return msg.contentParts.map(p => {
+        if (p.type === "text")
+            return { type: "text", text: p.text };
+        if (p.type === "image") {
+            if (p.data) {
+                return { type: "image", source: { type: "base64", media_type: p.mediaType ?? "image/png", data: p.data } };
+            }
+            return { type: "image", source: { type: "url", url: p.url } };
+        }
+        if (p.type === "audio") {
+            return { type: "text", text: `[audio: ${p.mediaType}]` };
+        }
+        return { type: "text", text: "" };
+    });
+}
+export function toOpenAIContent(msg) {
+    if (!msg.contentParts?.length)
+        return msg.content;
+    return msg.contentParts.map(p => {
+        if (p.type === "text")
+            return { type: "text", text: p.text };
+        if (p.type === "image") {
+            const url = p.data ? `data:${p.mediaType ?? "image/png"};base64,${p.data}` : p.url;
+            return { type: "image_url", image_url: { url, ...(p.detail ? { detail: p.detail } : {}) } };
+        }
+        if (p.type === "audio") {
+            return { type: "input_audio", input_audio: { data: p.data, format: p.mediaType?.split("/")[1] ?? "wav" } };
+        }
+        return { type: "text", text: "" };
+    });
+}

package/dist/providers/ollama.js

@@ -7,7 +7,16 @@ export class OllamaProvider {
         this.baseUrl = baseUrl;
     }
     toOllamaMessages(messages) {
-        return messages.map(m => ({ role: m.role, content: m.content }));
+        return messages.map(m => {
+            const images = [];
+            if (m.contentParts?.length) {
+                for (const p of m.contentParts) {
+                    if (p.type === "image" && p.data)
+                        images.push(p.data);
+                }
+            }
+            return { role: m.role, content: m.content, ...(images.length ? { images } : {}) };
+        });
     }
     async complete(messages, tools) {
         const resp = await fetch(`${this.baseUrl}/api/chat`, {

package/dist/providers/openai.d.ts

@@ -27,6 +27,7 @@ export declare class QwenProvider extends OpenAIProvider {
         maxRetries: number;
         baseDelay: number;
     });
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
 export declare class DeepSeekProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string, retry?: {
@@ -42,3 +43,9 @@ export declare class MiniMaxProvider extends OpenAIProvider {
     });
     stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
+export declare class KimiProvider extends OpenAIProvider {
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    });
+}

package/dist/providers/openai.js

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import { CircuitBreaker, normalizeToolCall } from "./base.js";
+import { CircuitBreaker, normalizeToolCall, toOpenAIContent } from "./base.js";
 export class OpenAIProvider {
     model;
     client;
@@ -22,7 +22,7 @@ export class OpenAIProvider {
     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 }));
+        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
@@ -46,15 +46,21 @@ export class OpenAIProvider {
         throw lastErr;
     }
     async *stream(messages, tools, extensions) {
-        const msgs = messages.map(m => ({ role: m.role, content: m.content }));
+        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
         const toolCallBufs = {};
         const stream = await this.client.chat.completions.create({
             model: this.model,
             messages: msgs,
             ...(tools.length ? { tools: this.buildTools(tools) } : {}),
             stream: true,
+            stream_options: { include_usage: true },
         });
+        let totalTokens = 0;
         for await (const chunk of stream) {
+            if (chunk.usage) {
+                totalTokens = chunk.usage.total_tokens;
+                continue;
+            }
             const choice = chunk.choices[0];
             if (!choice)
                 continue;
@@ -82,17 +88,63 @@ export class OpenAIProvider {
                 }
             }
         }
+        if (totalTokens > 0)
+            yield { type: "usage", totalTokens };
     }
 }
 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 MOONSHOT_BASE = "https://api.moonshot.cn/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) {
+    constructor(apiKey, model = "qwen-max", retry) {
         super(apiKey, model, retry, DASHSCOPE_BASE);
     }
+    async *stream(messages, tools, extensions) {
+        const enableThinking = Boolean(extensions?.enableThinking);
+        const thinkingBudget = extensions?.thinkingBudget;
+        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
+        const toolCallBufs = {};
+        const stream = await this.client.chat.completions.create({
+            model: this.model,
+            messages: msgs,
+            ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+            stream: true,
+            ...(enableThinking ? { extra_body: { enable_thinking: true, ...(thinkingBudget ? { thinking_budget: thinkingBudget } : {}) } } : {}),
+        });
+        for await (const chunk of stream) {
+            const choice = chunk.choices[0];
+            if (!choice)
+                continue;
+            const delta = choice.delta;
+            if (delta.reasoning_content)
+                yield { type: "thinking_delta", delta: delta.reasoning_content };
+            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 };
+                }
+            }
+        }
+    }
 }
 export class DeepSeekProvider extends OpenAIProvider {
     constructor(apiKey, model = "deepseek-chat", retry) {
@@ -100,7 +152,7 @@ export class DeepSeekProvider extends OpenAIProvider {
     }
     async *stream(messages, tools, extensions) {
         const exposeReasoning = extensions?.exposeReasoning ?? false;
-        const msgs = messages.map(m => ({ role: m.role, content: m.content }));
+        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
         const isReasoner = DEEPSEEK_REASONERS.has(this.model);
         const stream = await this.client.chat.completions.create({
             model: this.model,
@@ -124,7 +176,7 @@ export class MiniMaxProvider extends OpenAIProvider {
     }
     async *stream(messages, tools, extensions) {
         const exposeReasoning = extensions?.exposeReasoning ?? false;
-        const msgs = messages.map(m => ({ role: m.role, content: m.content }));
+        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
         const isReasoner = MINIMAX_REASONERS.has(this.model);
         const stream = await this.client.chat.completions.create({
             model: this.model,
@@ -142,3 +194,8 @@ export class MiniMaxProvider extends OpenAIProvider {
         }
     }
 }
+export class KimiProvider extends OpenAIProvider {
+    constructor(apiKey, model = "moonshot-v1-8k", retry) {
+        super(apiKey, model, retry, MOONSHOT_BASE);
+    }
+}

package/dist/safety/permissions.d.ts

@@ -3,15 +3,28 @@ export declare enum PermissionMode {
     PLAN = "PLAN",
     AUTO = "AUTO"
 }
+export interface Permission {
+    tool: string;
+    action: string;
+    allowed: boolean;
+    requiresApproval: boolean;
+    note: string;
+}
 export interface PermissionDecision {
     allowed: boolean;
     reason: string;
+    requiresApproval?: boolean;
+    matchedPermission?: Permission;
 }
 export declare class PermissionManager {
     private mode;
-    private grants;
+    private permissions;
     constructor(mode?: PermissionMode);
-    grant(resource: string, action: string): this;
-    revoke(resource: string, action: string): this;
+    grant(resource: string, action: string, options?: {
+        requiresApproval?: boolean;
+        note?: string;
+    }): this;
+    revoke(resource: string, action: string, note?: string): this;
+    private matchPermission;
     evaluate(resource: string, action: string): PermissionDecision;
 }

package/dist/safety/permissions.js

@@ -6,27 +6,44 @@ export var PermissionMode;
 })(PermissionMode || (PermissionMode = {}));
 export class PermissionManager {
     mode;
-    grants = new Map();
+    permissions = 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);
+    grant(resource, action, options = {}) {
+        const key = `${resource}:${action}`;
+        this.permissions.set(key, {
+            tool: resource, action, allowed: true,
+            requiresApproval: options.requiresApproval ?? false,
+            note: options.note ?? "",
+        });
         return this;
     }
-    revoke(resource, action) {
-        this.grants.get(resource)?.delete(action);
+    revoke(resource, action, note = "") {
+        const key = `${resource}:${action}`;
+        this.permissions.set(key, { tool: resource, action, allowed: false, requiresApproval: false, note });
         return this;
     }
+    matchPermission(tool, action) {
+        for (const key of [`${tool}:${action}`, `${tool}:*`, `*:${action}`, `*:*`]) {
+            const p = this.permissions.get(key);
+            if (p)
+                return p;
+        }
+        return undefined;
+    }
     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" };
+        const perm = this.matchPermission(resource, action);
+        if (!perm)
+            return { allowed: false, reason: "not granted" };
+        if (!perm.allowed)
+            return { allowed: false, reason: perm.note || "permission denied", matchedPermission: perm };
+        if (perm.requiresApproval)
+            return { allowed: false, reason: perm.note || "requires approval", requiresApproval: true, matchedPermission: perm };
+        return { allowed: true, reason: "granted", matchedPermission: perm };
     }
 }

package/dist/signals/gateway.d.ts

@@ -1,30 +1,34 @@
-import type { RuntimeSignal } from "./types.js";
+import type { RuntimeSignal, SignalSource } from "./types.js";
 import type { ScheduledPrompt } from "./scheduled.js";
 /**
- * SignalGateway — the entry point for all external signals into the agent.
+ * SignalGateway — 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
+ * Implements `SignalSource` so it can be passed directly to `AgentOptions.signalSource`.
+ * The gateway maintains an internal FIFO queue; `nextSignal()` drains it one entry at a time
+ * on each agent turn.
  *
- * Usage:
- *   const gateway = new SignalGateway()
- *   gateway.schedule(new ScheduledPrompt("summarize", Date.now() + 60_000))
- *   gateway.onSignal(sig => agent.ingestSignal(sig))
+ * Responsibilities:
+ * - Cron scheduling: fires ScheduledPrompts at the right wall-clock time (idempotent by goal+time)
+ * - Webhook / push ingestion: external code calls `ingest()` to push a signal in
+ * - Listener API: `onSignal()` for side-channel observers that don't need the pull interface
  */
-export declare class SignalGateway {
+export declare class SignalGateway implements SignalSource {
     private timers;
+    private queue;
     private listeners;
-    private router;
-    init(): Promise<void>;
+    /** Called by the agent loop each turn. Returns the oldest queued signal or null. */
+    nextSignal(): Promise<RuntimeSignal | null>;
+    /** Register a listener that is called synchronously whenever a signal is emitted. */
     onSignal(listener: (sig: RuntimeSignal) => void): void;
-    /** Schedule a ScheduledPrompt to fire at its runAtMs. Idempotent by goal. */
+    /** Schedule a ScheduledPrompt to fire at its `runAtMs`. Idempotent by goal+time. */
     schedule(prompt: ScheduledPrompt): void;
-    /** Cancel a scheduled prompt. */
+    /** Cancel a scheduled prompt before it fires. */
     cancel(goal: string, runAtMs: number): void;
-    /** Ingest a raw external signal (e.g. from a webhook handler). */
+    /** Push a raw signal directly (e.g. from a webhook handler). */
     ingest(sig: RuntimeSignal): void;
-    private emit;
+    /** Number of signals currently buffered in the queue. */
+    get depth(): number;
+    /** Clear all pending timers. Call when shutting down to avoid process leaks. */
     destroy(): void;
+    private emit;
 }

package/dist/signals/gateway.js

@@ -1,37 +1,34 @@
-// 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.
+ * SignalGateway — 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
+ * Implements `SignalSource` so it can be passed directly to `AgentOptions.signalSource`.
+ * The gateway maintains an internal FIFO queue; `nextSignal()` drains it one entry at a time
+ * on each agent turn.
  *
- * Usage:
- *   const gateway = new SignalGateway()
- *   gateway.schedule(new ScheduledPrompt("summarize", Date.now() + 60_000))
- *   gateway.onSignal(sig => agent.ingestSignal(sig))
+ * Responsibilities:
+ * - Cron scheduling: fires ScheduledPrompts at the right wall-clock time (idempotent by goal+time)
+ * - Webhook / push ingestion: external code calls `ingest()` to push a signal in
+ * - Listener API: `onSignal()` for side-channel observers that don't need the pull interface
  */
 export class SignalGateway {
     timers = new Map();
+    queue = [];
     listeners = [];
-    router = null;
-    async init() {
-        const kernel = await loadKernel();
-        this.router = new kernel.SignalRouter(1024);
+    // ── SignalSource interface (pull model) ─────────────────────────────────────
+    /** Called by the agent loop each turn. Returns the oldest queued signal or null. */
+    async nextSignal() {
+        return this.queue.shift() ?? null;
     }
+    // ── Push API ────────────────────────────────────────────────────────────────
+    /** Register a listener that is called synchronously whenever a signal is emitted. */
     onSignal(listener) {
         this.listeners.push(listener);
     }
-    /** Schedule a ScheduledPrompt to fire at its runAtMs. Idempotent by goal. */
+    /** Schedule a ScheduledPrompt to fire at its `runAtMs`. Idempotent by goal+time. */
     schedule(prompt) {
         const key = `cron:${prompt.goal}:${prompt.runAtMs}`;
         if (this.timers.has(key))
-            return; // already scheduled
-        const delay = prompt.runAtMs - Date.now();
+            return;
         const fire = () => {
             this.timers.delete(key);
             this.emit({
@@ -39,6 +36,7 @@ export class SignalGateway {
                 payload: { goal: prompt.goal, criteria: prompt.criteria, runAtMs: prompt.runAtMs, ...prompt.metadata },
             });
         };
+        const delay = prompt.runAtMs - Date.now();
         if (delay <= 0) {
             fire();
         }
@@ -46,7 +44,7 @@ export class SignalGateway {
             this.timers.set(key, setTimeout(fire, delay));
         }
     }
-    /** Cancel a scheduled prompt. */
+    /** Cancel a scheduled prompt before it fires. */
     cancel(goal, runAtMs) {
         const key = `cron:${goal}:${runAtMs}`;
         const t = this.timers.get(key);
@@ -55,17 +53,25 @@ export class SignalGateway {
             this.timers.delete(key);
         }
     }
-    /** Ingest a raw external signal (e.g. from a webhook handler). */
+    /** Push a raw signal directly (e.g. from a webhook handler). */
     ingest(sig) {
         this.emit(sig);
     }
-    emit(sig) {
-        for (const l of this.listeners)
-            l(sig);
+    /** Number of signals currently buffered in the queue. */
+    get depth() {
+        return this.queue.length;
     }
+    /** Clear all pending timers. Call when shutting down to avoid process leaks. */
     destroy() {
         for (const t of this.timers.values())
             clearTimeout(t);
         this.timers.clear();
+        this.queue.length = 0;
+    }
+    // ── Internal ────────────────────────────────────────────────────────────────
+    emit(sig) {
+        this.queue.push(sig);
+        for (const l of this.listeners)
+            l(sig);
     }
 }

package/dist/skills/loader.d.ts

@@ -5,7 +5,7 @@ export interface SkillMetadata {
     effort?: number;
     estimatedTokens?: number;
 }
-/** Read one skill file and return its full markdown content. */
+/** Read one skill file and return its body (frontmatter stripped). */
 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

@@ -12,10 +12,11 @@ function parseFrontmatter(content) {
     }
     return { meta, body: match[2] };
 }
-/** Read one skill file and return its full markdown content. */
+/** Read one skill file and return its body (frontmatter stripped). */
 export async function readSkillFile(skillDir, name) {
     try {
-        return await readFile(path.join(skillDir, `${name}.md`), "utf8");
+        const raw = await readFile(path.join(skillDir, `${name}.md`), "utf8");
+        return parseFrontmatter(raw).body;
     }
     catch {
         return null;

package/dist/types.d.ts

@@ -1,6 +1,32 @@
+export interface TextPart {
+    type: "text";
+    text: string;
+}
+export interface ImagePart {
+    type: "image";
+    /** Remote image URL (mutually exclusive with `data`). */
+    url?: string;
+    /** Raw base64-encoded image bytes (mutually exclusive with `url`). */
+    data?: string;
+    /** MIME type, e.g. `"image/png"`. Required when `data` is set. */
+    mediaType?: string;
+    /** OpenAI vision detail level. */
+    detail?: "auto" | "low" | "high";
+}
+export interface AudioPart {
+    type: "audio";
+    /** Raw base64-encoded audio bytes. */
+    data: string;
+    /** MIME type, e.g. `"audio/wav"`. */
+    mediaType: string;
+}
+export type ContentPart = TextPart | ImagePart | AudioPart;
 export interface Message {
     role: "system" | "user" | "assistant" | "tool";
+    /** Plain-text content. When `contentParts` is present, this holds only the text segments. */
     content: string;
+    /** Structured multimodal content. When present, takes precedence over `content` for provider calls. */
+    contentParts?: ContentPart[];
     tokenCount?: number;
     toolCalls?: ToolCall[];
 }
@@ -61,6 +87,16 @@ export interface PermissionRequestEvent extends StreamEvent {
     arguments: string;
     reason: string;
 }
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+export interface ProviderToolSpec {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
 export interface RetryConfig {
     maxRetries?: number;
     baseDelay?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "@deepstrike/core": "0.1.0",
+    "@deepstrike/core": "0.1.4",
     "openai": "^4.77.0"
   },
   "devDependencies": {