deepccc 0.2.24 → 0.2.26

package/README.md

@@ -57,9 +57,9 @@ npm run dev
 
 ![DeepCCC API 与 Web 设置](docs/deepccc-api-settings.png)
 
-## 核心能力
-
-- 有界结构化决策：程序化 `DecisionSession` 支持外部管理上下文、显式工具白名单、运行时结果校验和整轮截止时间；不改变默认聊天行为。详见 [接入文档](docs/decision-session.md)。
+## 核心能力
+
+- 有界结构化决策：程序化 `DecisionSession` 支持外部管理上下文、显式工具白名单、运行时结果校验和整轮截止时间；不改变默认聊天行为。详见 [接入文档](docs/decision-session.md)。
 
 - Web-first：多会话、持久化历史、实时流式过程、停止和恢复
 - 工具时间线：ChatCCC 风格 emoji 摘要、参数/结果折叠、省略行展开和状态记忆

package/bin/deepccc-cli.mjs

@@ -1,17 +1,17 @@
-#!/usr/bin/env node
-import { existsSync } from "node:fs";
-import { spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-
-const require = createRequire(import.meta.url);
-const pkgRoot = dirname(require.resolve("../package.json"));
-const distCli = join(pkgRoot, "dist", "cli.js");
-let args;
-if (existsSync(distCli)) {
-  args = [distCli, ...process.argv.slice(2)];
-} else {
-  args = [require.resolve("tsx/cli"), join(pkgRoot, "src", "cli.ts"), ...process.argv.slice(2)];
-}
-const result = spawnSync(process.execPath, args, { stdio: "inherit", cwd: process.cwd(), env: process.env });
-process.exit(result.status === null ? 1 : result.status);
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const pkgRoot = dirname(require.resolve("../package.json"));
+const distCli = join(pkgRoot, "dist", "cli.js");
+let args;
+if (existsSync(distCli)) {
+  args = [distCli, ...process.argv.slice(2)];
+} else {
+  args = [require.resolve("tsx/cli"), join(pkgRoot, "src", "cli.ts"), ...process.argv.slice(2)];
+}
+const result = spawnSync(process.execPath, args, { stdio: "inherit", cwd: process.cwd(), env: process.env });
+process.exit(result.status === null ? 1 : result.status);

package/bin/deepccc.mjs

@@ -1,32 +1,32 @@
-#!/usr/bin/env node
-import { existsSync } from "node:fs";
-import { spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-
-const require = createRequire(import.meta.url);
-const pkgRoot = dirname(require.resolve("../package.json"));
-const rawArgs = process.argv.slice(2);
-const distWebEntry = join(pkgRoot, "dist", "web-entry.js");
-const distCli = join(pkgRoot, "dist", "cli.js");
-const sourceMode = !existsSync(distWebEntry);
-const isLegacy = rawArgs.length > 0 && rawArgs[0] !== "web" && !["--reuse-existing", "--port", "--no-open", "--help", "-h"].includes(rawArgs[0]);
-
-if (isLegacy) {
-  console.error("[DeepCCC] CLI commands have moved to deepccc-cli; forwarding this invocation for compatibility.");
-  const args = sourceMode
-    ? [require.resolve("tsx/cli"), join(pkgRoot, "src", "cli.ts"), ...rawArgs]
-    : [distCli, ...rawArgs];
-  const result = spawnSync(process.execPath, args, { stdio: "inherit", cwd: process.cwd(), env: process.env });
-  process.exit(result.status === null ? 1 : result.status);
-}
-
-if (sourceMode) {
-  const result = spawnSync(process.execPath, [require.resolve("tsx/cli"), join(pkgRoot, "src", "web-entry.ts"), ...rawArgs], {
-    stdio: "inherit", cwd: process.cwd(), env: process.env,
-  });
-  process.exit(result.status === null ? 1 : result.status);
-}
-
-const { runWebEntry } = await import(new URL("../dist/web-entry.js", import.meta.url));
-await runWebEntry(rawArgs);
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const pkgRoot = dirname(require.resolve("../package.json"));
+const rawArgs = process.argv.slice(2);
+const distWebEntry = join(pkgRoot, "dist", "web-entry.js");
+const distCli = join(pkgRoot, "dist", "cli.js");
+const sourceMode = !existsSync(distWebEntry);
+const isLegacy = rawArgs.length > 0 && rawArgs[0] !== "web" && !["--reuse-existing", "--port", "--no-open", "--help", "-h"].includes(rawArgs[0]);
+
+if (isLegacy) {
+  console.error("[DeepCCC] CLI commands have moved to deepccc-cli; forwarding this invocation for compatibility.");
+  const args = sourceMode
+    ? [require.resolve("tsx/cli"), join(pkgRoot, "src", "cli.ts"), ...rawArgs]
+    : [distCli, ...rawArgs];
+  const result = spawnSync(process.execPath, args, { stdio: "inherit", cwd: process.cwd(), env: process.env });
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+if (sourceMode) {
+  const result = spawnSync(process.execPath, [require.resolve("tsx/cli"), join(pkgRoot, "src", "web-entry.ts"), ...rawArgs], {
+    stdio: "inherit", cwd: process.cwd(), env: process.env,
+  });
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+const { runWebEntry } = await import(new URL("../dist/web-entry.js", import.meta.url));
+await runWebEntry(rawArgs);

package/dist/completion-session.d.ts

@@ -0,0 +1,38 @@
+import { type ModelMessage } from 'ai';
+export interface CompletionConfig {
+    baseURL: string;
+    apiKey: string;
+    model: string;
+}
+export interface CompletionRequest {
+    messages: ModelMessage[];
+    timeoutMs: number;
+    json?: boolean;
+    temperature?: number;
+    maxOutputTokens?: number;
+    /** Provider-specific JSON options; cannot replace transport, messages or tools. */
+    extensions?: Record<string, unknown>;
+    maxContextChars?: number;
+    maxResponseChars?: number;
+}
+export type CompletionResult = {
+    metrics: {
+        durationMs: number;
+        modelCalls: number;
+    };
+} & ({
+    status: 'success';
+    content: string;
+    reasoning: string;
+} | {
+    status: 'timed_out' | 'cancelled' | 'invalid_output' | 'error';
+    diagnostic: {
+        code: string;
+        httpStatus?: number;
+    };
+});
+export declare class CompletionSession {
+    private readonly config;
+    constructor(config: CompletionConfig);
+    complete(request: CompletionRequest, externalSignal?: AbortSignal): Promise<CompletionResult>;
+}

package/dist/completion-session.js

@@ -0,0 +1,100 @@
+/** Opt-in stateless completion transport for integrations owning their complete prompts. */
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { streamText } from 'ai';
+import { jsonObjectFetch } from './json-mode-fetch.js';
+const protectedKeys = new Set(['messages', 'model', 'stream', 'tools', 'tool_choice', 'response_format', 'temperature', 'max_tokens', 'max_completion_tokens']);
+function positive(n) { if (!Number.isSafeInteger(n) || n < 1)
+    throw new Error('Positive integer budget required'); return n; }
+function raceAbort(work, signal) {
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(new Error('Interrupted'));
+        signal.addEventListener('abort', abort, { once: true });
+        Promise.resolve(work).then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+        if (signal.aborted)
+            abort();
+    });
+}
+export class CompletionSession {
+    config;
+    constructor(config) {
+        this.config = config;
+        if (!config.apiKey || !config.model)
+            throw new Error('Model credentials required');
+    }
+    async complete(request, externalSignal) {
+        const started = performance.now(), timeout = positive(request.timeoutMs);
+        if (timeout > 2147483647)
+            throw new Error('Deadline exceeds timer capacity');
+        const messages = JSON.parse(JSON.stringify(request.messages));
+        if (JSON.stringify(messages).length > positive(request.maxContextChars ?? 1_000_000))
+            throw new Error('Context budget exceeded');
+        const extensions = JSON.parse(JSON.stringify(request.extensions ?? {}));
+        if (Object.keys(extensions).some(key => protectedKeys.has(key)) || JSON.stringify(extensions).length > 8192)
+            throw new Error('Invalid request extension');
+        const responseLimit = positive(request.maxResponseChars ?? 1_000_000);
+        if (request.maxOutputTokens !== undefined)
+            positive(request.maxOutputTokens);
+        const controller = new AbortController();
+        let expired = false;
+        const cancel = () => controller.abort();
+        externalSignal?.addEventListener('abort', cancel, { once: true });
+        if (externalSignal?.aborted)
+            cancel();
+        const timer = setTimeout(() => { expired = true; controller.abort(); }, timeout);
+        let calls = 0;
+        const metrics = () => ({ durationMs: performance.now() - started, modelCalls: calls });
+        try {
+            if (controller.signal.aborted)
+                throw new Error('Interrupted');
+            const transport = request.json ? jsonObjectFetch() : globalThis.fetch;
+            const client = createOpenAICompatible({ name: 'completion', ...this.config, includeUsage: true,
+                fetch: async (url, init) => transport(url, { ...init, body: JSON.stringify({ ...JSON.parse(String(init?.body)), ...extensions }) }) });
+            calls++;
+            const result = streamText({ model: client(this.config.model), messages, allowSystemInMessages: true, temperature: request.temperature, maxOutputTokens: request.maxOutputTokens,
+                maxRetries: 0, abortSignal: controller.signal, onError: () => { } });
+            const iterator = result.fullStream[Symbol.asyncIterator]();
+            let content = '', reasoning = '', finish;
+            try {
+                while (true) {
+                    const next = await raceAbort(iterator.next(), controller.signal);
+                    if (controller.signal.aborted)
+                        throw new Error('Interrupted');
+                    if (next.done)
+                        break;
+                    const part = next.value;
+                    if (part.type === 'error') {
+                        const status = part.error?.statusCode;
+                        return { status: 'error', diagnostic: { code: 'provider_error', ...(typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 599 ? { httpStatus: status } : {}) }, metrics: metrics() };
+                    }
+                    if (part.type === 'text-delta')
+                        content += part.text;
+                    if (part.type === 'reasoning-delta')
+                        reasoning += part.text;
+                    if (part.type === 'finish')
+                        finish = part.finishReason;
+                    if (content.length + reasoning.length > responseLimit)
+                        return { status: 'invalid_output', diagnostic: { code: 'response_limit' }, metrics: metrics() };
+                }
+                if (controller.signal.aborted)
+                    throw new Error('Interrupted');
+                if (finish !== 'stop')
+                    return { status: 'invalid_output', diagnostic: { code: finish === 'length' ? 'output_truncated' : 'incomplete_response' }, metrics: metrics() };
+                return { status: 'success', content, reasoning, metrics: metrics() };
+            }
+            finally {
+                try {
+                    void Promise.resolve(iterator.return?.()).catch(() => { });
+                }
+                catch { /* best effort */ }
+            }
+        }
+        catch {
+            return { status: expired ? 'timed_out' : controller.signal.aborted ? 'cancelled' : 'error', diagnostic: { code: expired ? 'deadline_exceeded' : controller.signal.aborted ? 'cancelled' : 'transport_error' }, metrics: metrics() };
+        }
+        finally {
+            clearTimeout(timer);
+            externalSignal?.removeEventListener('abort', cancel);
+            controller.abort();
+        }
+    }
+}

package/dist/decision-session.js

@@ -1,7 +1,8 @@
 /** Bounded, text-only decisions with caller-owned context and explicit capabilities. */
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { createAnthropic } from "@ai-sdk/anthropic";
-import { asSchema, Output, streamText, tool } from "ai";
+import { asSchema, streamText, tool } from "ai";
+import { jsonObjectFetch } from "./json-mode-fetch.js";
 import { parseJsonResponse } from "./json-response.js";
 import { performance } from "node:perf_hooks";
 import { config, normalizeDeepCccProvider } from "./config.js";
@@ -92,7 +93,8 @@ export class DecisionSession {
         const baseURL = overrides.baseURL ?? config.baseURL;
         const client = provider === "anthropic"
             ? createAnthropic({ apiKey, baseURL: baseURL.trim().replace(/\/+$/, "") })
-            : createOpenAICompatible({ name: "deepccc", apiKey, baseURL, includeUsage: true });
+            : createOpenAICompatible({ name: "deepccc", apiKey, baseURL, includeUsage: true,
+                ...(this.outputMode === "json" ? { fetch: jsonObjectFetch() } : {}) });
         this.model = client(overrides.model ?? config.model);
         const effort = (overrides.effort ?? config.effort ?? "").trim();
         this.providerOptions = effort ? provider === "anthropic"
@@ -240,7 +242,7 @@ export class DecisionSession {
         const began = performance.now();
         metrics.modelCalls++;
         const result = streamText({ model: this.model, system: this.system, messages: [...messages],
-            ...(this.outputMode === "json" ? { output: Output.json() } : { tools: this.modelTools, toolChoice: "required" }),
+            ...(this.outputMode === "json" ? {} : { tools: this.modelTools, toolChoice: "required" }),
             maxRetries: 0, abortSignal: signal, maxOutputTokens: this.maxOutputTokens,
             // The SDK default logs raw errors. Return allowlisted diagnostics instead.
             onError: () => { },

package/dist/index.d.ts

@@ -6,6 +6,8 @@
 import { type DeepCccProvider } from "./config.js";
 import { type PermissionMode, type PermissionResolver } from "./permissions.js";
 export { DecisionSession } from "./decision-session.js";
+export { CompletionSession } from "./completion-session.js";
+export type { CompletionConfig, CompletionRequest, CompletionResult } from "./completion-session.js";
 export type { DecisionModelConfig, DecisionSessionOptions, DecisionRequest, DecisionResult, DecisionMetrics, DecisionFailureStatus, DecisionDiagnostic, DecisionTool, DecisionToolContext } from "./decision-session.js";
 export declare const DEFAULT_COMPACTION_TIMEOUT_MS: number;
 /**

package/dist/index.js

@@ -21,6 +21,7 @@ import { applyPrivacy, applyPrivacyToJson } from "./privacy.js";
 import { buildWorkspaceMap, needsWorkspaceOrientation } from "./workspace-map.js";
 import { compactToolLoopMessages } from "./turn-context.js";
 export { DecisionSession } from "./decision-session.js";
+export { CompletionSession } from "./completion-session.js";
 // ---------------------------------------------------------------------------
 // 系统提示词 — 编译期冻结常量（DeepCCC 英文品牌）
 // ---------------------------------------------------------------------------

package/dist/json-mode-fetch.d.ts

@@ -0,0 +1,2 @@
+/** Protocol JSON mode without client-side parsing of partial objects. */
+export declare function jsonObjectFetch(transport?: typeof fetch): typeof fetch;

package/dist/json-mode-fetch.js

@@ -0,0 +1,12 @@
+/** Protocol JSON mode without client-side parsing of partial objects. */
+export function jsonObjectFetch(transport = globalThis.fetch) {
+    return async (input, init) => {
+        if (typeof init?.body !== "string")
+            throw new Error("JSON mode requires a serialized request body");
+        const body = JSON.parse(init.body);
+        return transport(input, {
+            ...init,
+            body: JSON.stringify({ ...body, response_format: { type: "json_object" } }),
+        });
+    };
+}