dsh-plugin-subscriptions 0.5.1 → 0.5.2

package/lib/providers/copilot.js

@@ -18,6 +18,7 @@ import { resolveImages } from '../translate/resolved.js';
 import { streamChatCompletions, toChatMessages, toChatTools, } from '../translate/chat-completions.js';
 import { streamResponses, toResponsesInput, toResponsesTools } from '../translate/responses.js';
 import { httpLlmError, idleWatchdog, mapFetchFailure, ModelCatalogCache, discoverOrRetryAuth, isMissingOrInvalidCredential, oauthEndpointError, OAuthEndpointError, TokenManager, } from './common.js';
+import { proxiedFetch } from '../http.js';
 /**
  * Client id of the VS Code Copilot Chat GitHub App (pi-mono and
  * copilot2api-go use the same value): the app is pre-authorized for the
@@ -57,7 +58,7 @@ let vscodeVersionInflight;
  * @param forceRefresh - bypass the cache (a 401 `IDE token expired` retry).
  * @returns a `major.minor.patch` version string.
  */
-export async function latestVsCodeVersion(fetchFn = fetch, forceRefresh = false) {
+export async function latestVsCodeVersion(fetchFn = proxiedFetch, forceRefresh = false) {
     if (!forceRefresh && vscodeVersionCache !== undefined
         && Date.now() - vscodeVersionCache.at < VSCODE_VERSION_TTL_MS) {
         return vscodeVersionCache.version;
@@ -122,7 +123,7 @@ export function copilotHeaders(hasVision = false, vscodeVersion = FALLBACK_VSCOD
  * @param fetchFn - fetch implementation (injectable for tests).
  * @returns the Copilot API token and its expiry.
  */
-export async function exchangeCopilotToken(githubToken, fetchFn = fetch) {
+export async function exchangeCopilotToken(githubToken, fetchFn = proxiedFetch) {
     const response = await fetchFn(COPILOT_TOKEN_URL, {
         headers: {
             'authorization': `Bearer ${githubToken}`,
@@ -152,7 +153,7 @@ export async function exchangeCopilotToken(githubToken, fetchFn = fetch) {
  * @param fetchFn - fetch implementation (injectable for tests).
  * @returns the session to store.
  */
-export async function completeCopilotLogin(githubToken, fetchFn = fetch) {
+export async function completeCopilotLogin(githubToken, fetchFn = proxiedFetch) {
     const pair = await exchangeCopilotToken(githubToken, fetchFn);
     let account;
     try {
@@ -187,7 +188,7 @@ export async function completeCopilotLogin(githubToken, fetchFn = fetch) {
  * @param fetchFn - fetch implementation (injectable for tests).
  * @returns the fresh session to store.
  */
-export async function refreshCopilot(session, fetchFn = fetch) {
+export async function refreshCopilot(session, fetchFn = proxiedFetch) {
     const pair = await exchangeCopilotToken(session.refreshToken, fetchFn);
     return {
         accessToken: pair.accessToken,
@@ -244,7 +245,7 @@ function copilotReasoning(entry) {
  * @param fetchFn - fetch implementation (injectable for tests).
  * @returns discovered chat models in endpoint order.
  */
-export async function fetchCopilotModels(session, fetchFn = fetch) {
+export async function fetchCopilotModels(session, fetchFn = proxiedFetch) {
     const response = await fetchFn(COPILOT_MODELS_URL, {
         headers: {
             'authorization': `Bearer ${session.accessToken}`,
@@ -735,7 +736,7 @@ export class CopilotAdapter extends LlmAdapter {
                 // editor version is force-refreshed too: a 401 `IDE token expired`
                 // means GitHub raised its minimum VS Code version, and only a fresh
                 // Editor-Version header fixes that (a new token does not).
-                await latestVsCodeVersion(this.options.fetchFn ?? fetch, true);
+                await latestVsCodeVersion(this.options.fetchFn ?? proxiedFetch, true);
                 session = await this.options.tokens.session(true);
                 response = await this.request(options, session, watchdog.signal, wire, scope);
             }
@@ -771,13 +772,13 @@ export class CopilotAdapter extends LlmAdapter {
             // Captured completed reasoning replays ahead of its tool call.
             callId => this.replayFor(replayScopeKey, callId)))
             : copilotChatRequestBody(options, toChatMessages(messages, options.system));
-        return fetch(wire === 'responses' ? COPILOT_RESPONSES_URL : COPILOT_API_URL, {
+        return proxiedFetch(wire === 'responses' ? COPILOT_RESPONSES_URL : COPILOT_API_URL, {
             method: 'POST',
             headers: {
                 'authorization': `Bearer ${session.accessToken}`,
                 'accept': 'text/event-stream',
                 'content-type': 'application/json',
-                ...copilotHeaders(hasVision, await latestVsCodeVersion(this.options.fetchFn ?? fetch)),
+                ...copilotHeaders(hasVision, await latestVsCodeVersion(this.options.fetchFn ?? proxiedFetch)),
             },
             body: JSON.stringify(body),
             signal,

package/lib/providers/grok.js

@@ -8,6 +8,7 @@ import { decodeJwtPayload } from '../auth/jwt.js';
 import { resolveImages } from '../translate/resolved.js';
 import { streamResponses, toResponsesInput, toResponsesTools } from '../translate/responses.js';
 import { httpLlmError, idleWatchdog, mapFetchFailure, ModelCatalogCache, discoverOrRetryAuth, isMissingOrInvalidCredential, oauthEndpointError, OAuthEndpointError, TokenManager, } from './common.js';
+import { proxiedFetch } from '../http.js';
 export const GROK_CLIENT_ID = 'b1a00492-073a-47ea-816f-4c329264a828';
 export const GROK_DISCOVERY_URL = 'https://auth.x.ai/.well-known/openid-configuration';
 export const GROK_API_URL = 'https://api.x.ai/v1/responses';
@@ -40,7 +41,7 @@ let discoveryCache;
 export async function grokDiscovery() {
     if (discoveryCache !== undefined)
         return discoveryCache;
-    const response = await fetch(GROK_DISCOVERY_URL);
+    const response = await proxiedFetch(GROK_DISCOVERY_URL);
     if (!response.ok)
         throw await oauthEndpointError(response, 'grok OIDC discovery');
     const document = await response.json();
@@ -147,7 +148,7 @@ function grokSession(tokens, tokenEndpoint, fallbackRefreshToken) {
  */
 export async function exchangeGrokCode(code, verifier, redirectUri, challenge) {
     const discovery = await grokDiscovery();
-    const response = await fetch(discovery.tokenEndpoint, {
+    const response = await proxiedFetch(discovery.tokenEndpoint, {
         method: 'POST',
         headers: { 'content-type': 'application/x-www-form-urlencoded' },
         body: new URLSearchParams({
@@ -174,7 +175,7 @@ export async function exchangeGrokCode(code, verifier, redirectUri, challenge) {
  * @returns the fresh session to store.
  */
 export async function refreshGrok(session) {
-    const response = await fetch(session.tokenEndpoint, {
+    const response = await proxiedFetch(session.tokenEndpoint, {
         method: 'POST',
         headers: { 'content-type': 'application/x-www-form-urlencoded' },
         body: new URLSearchParams({
@@ -223,7 +224,7 @@ function grokResetsAt(value) {
  * @param signal - caller cancellation from the RPC transport.
  * @returns the mapped usage snapshot.
  */
-export async function fetchGrokUsage(session, fetchFn = fetch, signal) {
+export async function fetchGrokUsage(session, fetchFn = proxiedFetch, signal) {
     const response = await fetchFn(GROK_BILLING_URL, {
         headers: {
             'authorization': `Bearer ${session.accessToken}`,
@@ -313,7 +314,7 @@ function grokCliReasoning(entry) {
  * @param fetchFn - fetch implementation (injectable for tests).
  * @returns model id → contributed metadata.
  */
-export async function fetchGrokCliCatalog(session, fetchFn = fetch) {
+export async function fetchGrokCliCatalog(session, fetchFn = proxiedFetch) {
     const response = await fetchFn(GROK_CLI_MODELS_URL, {
         headers: {
             'authorization': `Bearer ${session.accessToken}`,
@@ -385,7 +386,7 @@ function grokPriorMeta(prior) {
  *   catalog is down or omits a model.
  * @returns discovered chat models in endpoint order.
  */
-export async function fetchGrokModels(session, fetchFn = fetch, onWarn, previous) {
+export async function fetchGrokModels(session, fetchFn = proxiedFetch, onWarn, previous) {
     const previousById = previous === undefined || previous.length === 0
         ? undefined
         : new Map(previous.map(model => [model.id, model]));
@@ -562,7 +563,7 @@ export class GrokAdapter extends LlmAdapter {
             store: false,
             stream: true,
         };
-        return fetch(GROK_API_URL, {
+        return proxiedFetch(GROK_API_URL, {
             method: 'POST',
             headers: {
                 'authorization': `Bearer ${session.accessToken}`,

package/lib/tools/image-generate.js

@@ -18,6 +18,7 @@ import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 import { AttachmentId } from '@deepseek-ai/dsh-attachment';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { httpLlmError, TokenManager } from '../providers/common.js';
+import { proxiedFetch } from '../http.js';
 /** Endpoint the codex generation request is posted to. */
 export const IMAGE_GENERATE_URL = 'https://chatgpt.com/backend-api/codex/images/generations';
 /** The image model the codex subscription endpoint serves. */
@@ -241,7 +242,7 @@ export function createImageGenerateTool(options) {
             content: result.content.filter(block => block.type === 'text'),
         }),
         async execute(args, exec) {
-            const fetchFn = options.fetchFn ?? fetch;
+            const fetchFn = options.fetchFn ?? proxiedFetch;
             // Provider selection: the preferred provider (default gpt) when logged
             // in, the other one as the fallback. A configured-but-logged-out manager
             // still resolves through `session()` below so the standard log-in hint

package/lib/tools/video-generate.js

@@ -13,6 +13,7 @@ import { basename, join } from 'node:path';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { httpLlmError, TokenManager } from '../providers/common.js';
+import { proxiedFetch } from '../http.js';
 /** Endpoint the generation request is posted to. */
 export const VIDEO_GENERATE_URL = 'https://api.x.ai/v1/videos/generations';
 /** The video model the grok subscription endpoint serves. */
@@ -197,7 +198,7 @@ export function createVideoGenerateTool(options) {
         async execute(args, exec) {
             const body = buildVideoGenerateBody(args);
             const session = await options.tokens.session();
-            const fetchFn = options.fetchFn ?? fetch;
+            const fetchFn = options.fetchFn ?? proxiedFetch;
             const headers = {
                 'authorization': `Bearer ${session.accessToken}`,
                 'accept': 'application/json',

package/lib/tools/x-search.js

@@ -6,6 +6,7 @@
  */
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { httpLlmError, TokenManager } from '../providers/common.js';
+import { proxiedFetch } from '../http.js';
 /** Endpoint the search request is posted to. */
 export const X_SEARCH_URL = 'https://api.x.ai/v1/responses';
 /** Grok model the search runs on (a catalog model of the grok provider). */
@@ -172,7 +173,7 @@ export function createXSearchTool(options) {
         async execute(args, exec) {
             const request = buildXSearchRequest(args);
             const session = await options.tokens.session();
-            const response = await (options.fetchFn ?? fetch)(X_SEARCH_URL, {
+            const response = await (options.fetchFn ?? proxiedFetch)(X_SEARCH_URL, {
                 method: 'POST',
                 headers: {
                     'authorization': `Bearer ${session.accessToken}`,

package/lib/translate/antigravity.d.ts

@@ -0,0 +1,110 @@
+/**
+ * DeepSeek Harness message/tool vocabulary to Antigravity's Gemini-shaped
+ * v1internal request envelope, plus response/SSE translation back to the
+ * harness streaming contract.
+ */
+import type { GenerateOptions, StreamChunk, TokenUsage, ToolSchema } from '@deepseek-ai/dsh-llm';
+import type { TranslatableMessage } from './resolved.js';
+/** Minimal Gemini part shape used by v1internal. */
+export interface AntigravityPart {
+    text?: string;
+    thought?: boolean;
+    thoughtSignature?: string;
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+    functionCall?: {
+        id?: string;
+        name?: string;
+        args?: unknown;
+    };
+    functionResponse?: {
+        id: string;
+        name: string;
+        response: unknown;
+    };
+}
+/** Full Antigravity request envelope. */
+export interface AntigravityRequest {
+    project: string;
+    requestId: string;
+    model: string;
+    userAgent: 'antigravity';
+    requestType: 'agent';
+    request: {
+        contents: {
+            role: 'user' | 'model';
+            parts: AntigravityPart[];
+        }[];
+        sessionId: string;
+        systemInstruction?: {
+            parts: {
+                text: string;
+            }[];
+        };
+        tools?: {
+            functionDeclarations: Record<string, unknown>[];
+        }[];
+        toolConfig?: {
+            functionCallingConfig: {
+                mode: 'VALIDATED';
+            };
+        };
+        generationConfig?: Record<string, unknown>;
+    };
+}
+/** Map harness tool schemas to Gemini function declarations. */
+export declare function toAntigravityTools(tools: readonly ToolSchema[]): {
+    functionDeclarations: Record<string, unknown>[];
+}[];
+/**
+ * Convert resolved harness messages into Gemini contents. Function response
+ * names are recovered from prior tool calls because DSH correlates results by
+ * id while the Gemini wire requires both id and name.
+ */
+export declare function toAntigravityContents(messages: readonly TranslatableMessage[]): {
+    role: 'user' | 'model';
+    parts: AntigravityPart[];
+}[];
+/** Build one v1internal generateContent/streamGenerateContent request. */
+export declare function toAntigravityRequest(options: GenerateOptions, messages: readonly TranslatableMessage[], projectId: string): AntigravityRequest;
+/** Antigravity SSE/non-stream response subset. */
+export interface AntigravityResponseEvent {
+    response?: {
+        candidates?: {
+            content?: {
+                parts?: AntigravityPart[];
+            };
+            finishReason?: string;
+        }[];
+        usageMetadata?: {
+            promptTokenCount?: number;
+            candidatesTokenCount?: number;
+            thoughtsTokenCount?: number;
+            totalTokenCount?: number;
+            cachedContentTokenCount?: number;
+        };
+    };
+}
+/** Map Gemini usage metadata to the harness's disjoint counters. */
+export declare function mapAntigravityUsage(metadata: NonNullable<NonNullable<AntigravityResponseEvent['response']>['usageMetadata']>): TokenUsage;
+/** Push translator for both parsed SSE events and one non-stream response. */
+export declare class AntigravityStreamTranslator {
+    private blocks;
+    private closed;
+    private nextIndex;
+    private sawContent;
+    private sawToolCall;
+    terminated: boolean;
+    private open;
+    private close;
+    private closeAll;
+    private finish;
+    /** Process one decoded Antigravity response frame. */
+    push(event: AntigravityResponseEvent): StreamChunk[];
+}
+/** Consume Antigravity's SSE response into the DSH streaming contract. */
+export declare function streamAntigravity(stream: ReadableStream<Uint8Array>, onActivity?: () => void): AsyncGenerator<StreamChunk>;
+/** Translate a non-stream generateContent response using the same state machine. */
+export declare function parseAntigravityResponse(event: AntigravityResponseEvent): StreamChunk[];

package/lib/translate/antigravity.js

@@ -0,0 +1,303 @@
+/**
+ * DeepSeek Harness message/tool vocabulary to Antigravity's Gemini-shaped
+ * v1internal request envelope, plus response/SSE translation back to the
+ * harness streaming contract.
+ */
+import { randomUUID } from 'node:crypto';
+import { CallId, EMPTY_RESPONSE_CODE, LlmError } from '@deepseek-ai/dsh-llm';
+import { parseSse } from './sse.js';
+/** Flatten a harness tool result to the JSON value Antigravity receives. */
+function toolResultValue(block) {
+    const text = block.content.map(part => part.type === 'text' ? part.text : '').join('');
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { output: text, ...block.isError === true ? { isError: true } : {} };
+    }
+}
+/** Safely read per-block replay metadata emitted by this adapter. */
+function replayBlocks(message) {
+    const source = message.source;
+    if (source?.kind !== 'model' || typeof source.replayState !== 'object' || source.replayState === null)
+        return [];
+    const envelope = source.replayState;
+    const response = envelope.response;
+    if (response?.kind !== 'antigravity' || response.version !== 1 || !Array.isArray(envelope.blocks))
+        return [];
+    return envelope.blocks.map((entry) => {
+        if (typeof entry !== 'object' || entry === null)
+            return {};
+        const signature = entry.thoughtSignature;
+        return typeof signature === 'string' && signature.length > 0 ? { thoughtSignature: signature } : {};
+    });
+}
+/** Map harness tool schemas to Gemini function declarations. */
+export function toAntigravityTools(tools) {
+    if (tools.length === 0)
+        return [];
+    return [{
+            functionDeclarations: tools.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            })),
+        }];
+}
+/**
+ * Convert resolved harness messages into Gemini contents. Function response
+ * names are recovered from prior tool calls because DSH correlates results by
+ * id while the Gemini wire requires both id and name.
+ */
+export function toAntigravityContents(messages) {
+    const out = [];
+    const callNames = new Map();
+    for (const message of messages) {
+        if (message.role === 'system')
+            continue;
+        const role = message.role === 'assistant' ? 'model' : 'user';
+        const metadata = replayBlocks(message);
+        const parts = [];
+        for (let index = 0; index < message.content.length; index++) {
+            const block = message.content[index];
+            switch (block.type) {
+                case 'text':
+                    // Antigravity's Claude-backed models reject empty text parts.
+                    parts.push({ text: block.text.trim().length > 0 ? block.text : '.' });
+                    break;
+                case 'image':
+                    if ('dataBase64' in block) {
+                        parts.push({ inlineData: { mimeType: block.mediaType, data: block.dataBase64 } });
+                    }
+                    break;
+                case 'tool-call': {
+                    callNames.set(String(block.id), block.name);
+                    let args;
+                    try {
+                        args = JSON.parse(block.arguments);
+                    }
+                    catch {
+                        args = {};
+                    }
+                    parts.push({
+                        functionCall: { id: String(block.id), name: block.name, args },
+                        ...metadata[index]?.thoughtSignature === undefined
+                            ? {}
+                            : { thoughtSignature: metadata[index].thoughtSignature },
+                    });
+                    break;
+                }
+                case 'tool-result': {
+                    const id = String(block.toolCallId);
+                    parts.push({
+                        functionResponse: {
+                            id,
+                            name: callNames.get(id) ?? '',
+                            response: toolResultValue(block),
+                        },
+                    });
+                    break;
+                }
+                default:
+                    // Reasoning is not replayed without its provider signature. The
+                    // signature-bearing metadata remains attached to tool-call blocks.
+                    break;
+            }
+        }
+        if (parts.length === 0)
+            continue;
+        const previous = out.at(-1);
+        if (previous?.role === role)
+            previous.parts.push(...parts);
+        else
+            out.push({ role, parts });
+    }
+    return out;
+}
+/** Build one v1internal generateContent/streamGenerateContent request. */
+export function toAntigravityRequest(options, messages, projectId) {
+    const tools = toAntigravityTools(options.tools ?? []);
+    const generationConfig = {
+        ...options.maxTokens === undefined ? {} : { maxOutputTokens: options.maxTokens },
+        ...options.temperature === undefined ? {} : { temperature: options.temperature },
+        ...options.stop === undefined || options.stop.length === 0 ? {} : { stopSequences: options.stop },
+        ...options.reasoningEffort === undefined ? {} : {
+            thinkingConfig: { thinkingLevel: String(options.reasoningEffort), includeThoughts: true },
+        },
+    };
+    const systemTexts = messages.flatMap(message => message.role === 'system'
+        ? message.content.filter((block) => block.type === 'text').map(block => block.text)
+        : []);
+    const system = options.system ?? (systemTexts.length > 0 ? systemTexts.join('\n\n') : undefined);
+    const sessionId = options.sessionId === undefined ? randomUUID() : String(options.sessionId);
+    return {
+        project: projectId,
+        requestId: `agent/${String(Date.now())}/${randomUUID()}/4`,
+        model: options.model,
+        userAgent: 'antigravity',
+        requestType: 'agent',
+        request: {
+            contents: toAntigravityContents(messages),
+            sessionId,
+            ...system === undefined || system.length === 0 ? {} : { systemInstruction: { parts: [{ text: system }] } },
+            ...tools.length === 0 ? {} : {
+                tools,
+                toolConfig: { functionCallingConfig: { mode: 'VALIDATED' } },
+            },
+            ...Object.keys(generationConfig).length === 0 ? {} : { generationConfig },
+        },
+    };
+}
+/** Map Gemini usage metadata to the harness's disjoint counters. */
+export function mapAntigravityUsage(metadata) {
+    const cached = metadata.cachedContentTokenCount ?? 0;
+    return {
+        inputTokens: Math.max(0, (metadata.promptTokenCount ?? 0) - cached),
+        outputTokens: metadata.candidatesTokenCount ?? 0,
+        ...cached > 0 ? { cacheReadTokens: cached } : {},
+        ...metadata.thoughtsTokenCount === undefined ? {} : { reasoningTokens: metadata.thoughtsTokenCount },
+    };
+}
+/** Push translator for both parsed SSE events and one non-stream response. */
+export class AntigravityStreamTranslator {
+    blocks = new Map();
+    closed = [];
+    nextIndex = 0;
+    sawContent = false;
+    sawToolCall = false;
+    terminated = false;
+    open(key, kind, chunks, values = {}) {
+        const block = { index: this.nextIndex++, kind, text: '', ...values };
+        this.blocks.set(key, block);
+        chunks.push({ type: 'block-start', index: block.index, blockType: kind });
+        return block;
+    }
+    close(key, chunks) {
+        const block = this.blocks.get(key);
+        if (block === undefined)
+            return;
+        this.blocks.delete(key);
+        let content;
+        if (block.kind === 'text')
+            content = { type: 'text', text: block.text };
+        else if (block.kind === 'reasoning')
+            content = { type: 'reasoning', text: block.text };
+        else
+            content = {
+                type: 'tool-call',
+                id: CallId(block.id ?? `call_${randomUUID().replaceAll('-', '')}`),
+                name: block.name ?? '',
+                arguments: block.text,
+            };
+        this.closed[block.index] = block.thoughtSignature === undefined ? {} : { thoughtSignature: block.thoughtSignature };
+        chunks.push({ type: 'block-end', index: block.index, block: content });
+    }
+    closeAll(chunks) {
+        for (const key of [...this.blocks.keys()])
+            this.close(key, chunks);
+    }
+    finish(reason) {
+        const replayState = {
+            response: { kind: 'antigravity', version: 1 },
+            blocks: this.closed,
+        };
+        if (!this.sawContent) {
+            return {
+                type: 'finish',
+                reason: { kind: 'error', failure: { message: 'Antigravity returned no content', code: EMPTY_RESPONSE_CODE } },
+            };
+        }
+        if (reason === 'MAX_TOKENS')
+            return { type: 'finish', reason: { kind: 'max-tokens' }, replayState };
+        if (reason === 'SAFETY' || reason === 'RECITATION' || reason === 'BLOCKLIST') {
+            return {
+                type: 'finish',
+                reason: { kind: 'error', failure: { message: `Antigravity blocked the response (${reason})`, code: 'CONTENT_FILTER' } },
+            };
+        }
+        return { type: 'finish', reason: { kind: this.sawToolCall ? 'tool-calls' : 'stop' }, replayState };
+    }
+    /** Process one decoded Antigravity response frame. */
+    push(event) {
+        if (this.terminated)
+            return [];
+        const chunks = [];
+        const candidate = event.response?.candidates?.[0];
+        for (const [partIndex, part] of (candidate?.content?.parts ?? []).entries()) {
+            if (part.thought === true && typeof part.text === 'string' && part.text.length > 0) {
+                const block = this.blocks.get('reasoning') ?? this.open('reasoning', 'reasoning', chunks);
+                block.text += part.text;
+                if (part.thoughtSignature !== undefined)
+                    block.thoughtSignature = part.thoughtSignature;
+                this.sawContent = true;
+                chunks.push({ type: 'reasoning-delta', index: block.index, text: part.text });
+            }
+            else if (typeof part.text === 'string' && part.text.length > 0) {
+                const block = this.blocks.get('text') ?? this.open('text', 'text', chunks);
+                block.text += part.text;
+                if (part.thoughtSignature !== undefined)
+                    block.thoughtSignature = part.thoughtSignature;
+                this.sawContent = true;
+                chunks.push({ type: 'text-delta', index: block.index, text: part.text });
+            }
+            else if (part.functionCall !== undefined) {
+                const call = part.functionCall;
+                const id = typeof call.id === 'string' && call.id.length > 0
+                    ? call.id
+                    : `call_${randomUUID().replaceAll('-', '')}`;
+                const key = `call:${id}:${String(partIndex)}`;
+                const args = JSON.stringify(call.args ?? {});
+                const block = this.open(key, 'tool-call', chunks, {
+                    id,
+                    name: call.name ?? '',
+                    ...part.thoughtSignature === undefined ? {} : { thoughtSignature: part.thoughtSignature },
+                });
+                block.text = args;
+                this.sawContent = true;
+                this.sawToolCall = true;
+                chunks.push({
+                    type: 'tool-call-delta',
+                    index: block.index,
+                    id: CallId(id),
+                    name: call.name ?? '',
+                    argumentsDelta: args,
+                });
+                this.close(key, chunks);
+            }
+        }
+        if (candidate?.finishReason !== undefined) {
+            this.closeAll(chunks);
+            const usage = event.response?.usageMetadata;
+            if (usage !== undefined)
+                chunks.push({ type: 'usage', usage: mapAntigravityUsage(usage) });
+            chunks.push(this.finish(candidate.finishReason));
+            this.terminated = true;
+        }
+        return chunks;
+    }
+}
+/** Consume Antigravity's SSE response into the DSH streaming contract. */
+export async function* streamAntigravity(stream, onActivity) {
+    const translator = new AntigravityStreamTranslator();
+    for await (const event of parseSse(stream, onActivity)) {
+        if (event.data === '[DONE]')
+            break;
+        let parsed;
+        try {
+            parsed = JSON.parse(event.data);
+        }
+        catch {
+            throw new LlmError(`malformed Antigravity SSE payload: ${event.data.slice(0, 120)}`, 'MALFORMED_RESPONSE');
+        }
+        yield* translator.push(parsed);
+        if (translator.terminated)
+            return;
+    }
+    if (!translator.terminated) {
+        throw new LlmError('Antigravity SSE stream ended before a finish chunk', 'STREAM_CLOSED');
+    }
+}
+/** Translate a non-stream generateContent response using the same state machine. */
+export function parseAntigravityResponse(event) {
+    return new AntigravityStreamTranslator().push(event);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscriptions",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Use ChatGPT (Codex), Claude, Grok (X Premium), and GitHub Copilot subscriptions as DeepSeek Harness LLM providers, with OAuth login from the web Settings page",
   "license": "MIT",
   "repository": {
@@ -49,12 +49,18 @@
       ]
     }
   },
+  "scripts": {
+    "build": "tsc && tsdown",
+    "test": "tsc -p tsconfig.test.json && node --test lib-test/test/",
+    "prepare": "tsdown -c tsdown.prepare.config.ts",
+    "prepublishOnly": "pnpm build && pnpm test"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-attachment": "^0.1.0-rc.5",
-    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.5",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.5",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.5",
+    "@deepseek-ai/dsh-attachment": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-home-paths": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
     "@deepseek-ai/schemastery": "^3.18.1"
   },
   "devDependencies": {
@@ -79,8 +85,7 @@
     "tsdown": "^0.15.0",
     "typescript": "^5.8.0"
   },
-  "scripts": {
-    "build": "tsc && tsdown",
-    "test": "tsc -p tsconfig.test.json && node --test lib-test/test/"
+  "dependencies": {
+    "undici": "^7.0.0"
   }
-}
+}