deepccc 0.2.24 → 0.2.25

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,98 @@
+/** Opt-in stateless completion transport for integrations owning their complete prompts. */
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { Output, streamText } from 'ai';
+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 client = createOpenAICompatible({ name: 'completion', ...this.config, includeUsage: true,
+                fetch: async (url, init) => fetch(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,
+                ...(request.json ? { output: Output.json() } : {}), 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/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/docs/completion-session.md

@@ -0,0 +1,36 @@
+# Caller-owned completions
+
+`CompletionSession` is an opt-in stateless OpenAI-compatible transport. Pass the
+entire `messages` array; no system guidance, workspace files, skills, tools,
+history or compaction is injected. This is useful when comparing integrations
+without rewriting their established prompt builders.
+
+```js
+import {CompletionSession} from 'deepccc';
+const session = new CompletionSession({
+  apiKey: process.env.DEEPCCC_API_KEY,
+  baseURL: process.env.DEEPCCC_BASE_URL,
+  model: process.env.DEEPCCC_MODEL,
+});
+const result = await session.complete({
+  messages: [{role: 'system', content: 'Return JSON only.'},
+             {role: 'user', content: 'Return an object with ok=true.'}],
+  json: true, timeoutMs: 5000, maxOutputTokens: 256, temperature: 0.1,
+});
+if (result.status === 'success') console.log(result.content);
+```
+
+JSON mode sends `response_format: {type: 'json_object'}`; callers still parse,
+validate and authorize results. No local syntax repair or automatic retry is
+performed here. Completion is accepted only after a normal stop, never a length
+limit or interrupted stream. Text mode preserves plain-text output. Parallel
+calls do not share mutable history. `timeoutMs` covers stream consumption;
+optional cancellation is the second argument. Context/response character limits
+default to one million each. Oversize input and invalid options throw before
+network activity; runtime failures return fixed diagnostics without raw errors.
+
+Optional `extensions` passes caller-supplied provider-specific JSON options.
+It cannot override messages, model, streaming, tool settings, response format,
+temperature or token limits. Keep credentials in config, not extensions. No
+messages, headers or generated content are logged or persisted by this class.
+Metrics include duration and request count. Remote cancellation is best effort.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.2.24",
+  "version": "0.2.25",
   "description": "A lightweight coding agent with OpenAI-compatible and Anthropic Messages API support.",
   "license": "Apache-2.0",
   "keywords": [