dsh-plugin-subscription-usage 0.0.0-stage → 0.2.0

package/lib/translate/antigravity-schema.js

@@ -0,0 +1,145 @@
+/** Model-specific tool schemas for Antigravity's Gemini and custom-tool bridges. */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+const CUSTOM_KEYS = new Set(['type', 'description', 'properties', 'required', 'items', 'enum']);
+function object(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Resolve local references before removing definitions; reject cycles and remote references. */
+function resolve(value, root, refs = new Set()) {
+    if (Array.isArray(value))
+        return value.map(item => resolve(item, root, refs));
+    if (!object(value))
+        return value;
+    if (typeof value.$ref === 'string') {
+        const ref = value.$ref;
+        if (!ref.startsWith('#/') || refs.has(ref)) {
+            throw new LlmError(`Antigravity tool schema has an unsupported reference: ${ref}`, 'INVALID_REQUEST');
+        }
+        let target = root;
+        for (const segment of ref.slice(2).split('/')) {
+            const key = segment.replaceAll('~1', '/').replaceAll('~0', '~');
+            target = object(target) && Object.hasOwn(target, key) ? target[key] : undefined;
+        }
+        if (!object(target))
+            throw new LlmError(`Antigravity tool schema reference is missing: ${ref}`, 'INVALID_REQUEST');
+        const { $ref: _ref, ...siblings } = value;
+        return resolve({ ...target, ...siblings }, root, new Set([...refs, ref]));
+    }
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => !['$schema', '$id', '$defs', 'definitions'].includes(key))
+        .map(([key, item]) => [key, key === 'properties' && object(item)
+            ? Object.fromEntries(Object.entries(item).map(([name, property]) => [name, resolve(property, root, refs)]))
+            : resolve(item, root, refs)]));
+}
+/** Numeric types widen to `number`: every integer is also a number. */
+const NUMERIC = new Set(['integer', 'number']);
+/** The strings one alternative is limited to (`enum` or `const`), or undefined when unconstrained. */
+function stringChoices(schema) {
+    if (typeof schema.const === 'string')
+        return [schema.const];
+    return Array.isArray(schema.enum) && schema.enum.every(entry => typeof entry === 'string') ? schema.enum : undefined;
+}
+/**
+ * Fold schema alternatives into one shape this bridge can express, never
+ * narrower than any alternative: picking one branch would make the tool
+ * uncallable with the others' values, which is worse than a looser contract
+ * the tool still validates. Objects keep the union of their properties and
+ * only the fields every alternative requires; scalars of one type keep that
+ * type (and a string choice union); anything heterogeneous is unconstrained.
+ */
+function widen(variants) {
+    const members = variants.filter(object);
+    if (members.length === 0 || members.length !== variants.length)
+        return {};
+    const types = new Set(members.map(member => member.type));
+    const type = types.size === 1 ? [...types][0]
+        : [...types].every(entry => typeof entry === 'string' && NUMERIC.has(entry)) ? 'number' : undefined;
+    if (typeof type !== 'string')
+        return {};
+    if (type === 'object') {
+        const properties = {};
+        for (const member of members) {
+            if (!object(member.properties))
+                continue;
+            for (const [name, property] of Object.entries(member.properties)) {
+                properties[name] = !Object.hasOwn(properties, name) || JSON.stringify(properties[name]) === JSON.stringify(property)
+                    ? property
+                    : widen([properties[name], property]);
+            }
+        }
+        const required = members
+            .map(member => Array.isArray(member.required) ? member.required.filter(entry => typeof entry === 'string') : [])
+            .reduce((shared, next) => shared.filter(name => next.includes(name)));
+        return {
+            type,
+            ...Object.keys(properties).length === 0 ? {} : { properties },
+            ...required.length === 0 ? {} : { required },
+        };
+    }
+    if (type === 'array') {
+        return { type, items: widen(members.map(member => member.items ?? {})) };
+    }
+    const choices = members.map(stringChoices);
+    return choices.every(entry => entry !== undefined)
+        ? { type, enum: [...new Set(choices.flat())] }
+        : { type };
+}
+/** Merge `extra` into `schema`: properties and required accumulate, other keywords override. */
+function absorb(schema, extra) {
+    const { properties, required, ...rest } = extra;
+    Object.assign(schema, rest);
+    if (object(properties))
+        schema.properties = { ...object(schema.properties) ? schema.properties : {}, ...properties };
+    if (Array.isArray(required)) {
+        schema.required = [...new Set([...Array.isArray(schema.required) ? schema.required : [], ...required])];
+    }
+}
+/** Keep property names intact while reducing schema keywords for Claude/GPT-OSS. */
+function custom(value) {
+    if (!object(value))
+        return value;
+    const schema = { ...value };
+    // An intersection holds every member's constraints at once.
+    if (Array.isArray(schema.allOf)) {
+        const members = schema.allOf.filter(object);
+        delete schema.allOf;
+        for (const member of members)
+            absorb(schema, member);
+    }
+    for (const keyword of ['anyOf', 'oneOf']) {
+        if (!Array.isArray(schema[keyword]))
+            continue;
+        const variants = schema[keyword].filter(item => !object(item) || item.type !== 'null');
+        delete schema[keyword];
+        absorb(schema, variants.length === 1 && object(variants[0]) ? variants[0] : widen(variants));
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (!CUSTOM_KEYS.has(key))
+            continue;
+        if (key === 'properties' && object(value)) {
+            out[key] = Object.fromEntries(Object.entries(value).map(([name, property]) => [name, custom(property)]));
+        }
+        else if (key === 'items')
+            out[key] = custom(value);
+        else if (key === 'type' && Array.isArray(value)) {
+            const types = value.filter(type => type !== 'null');
+            const type = types.length === 1 ? types[0]
+                : types.length > 0 && types.every(entry => NUMERIC.has(entry)) ? 'number' : undefined;
+            if (type !== undefined)
+                out[key] = type;
+        }
+        else if (key !== 'enum' || Array.isArray(value) && value.every(entry => typeof entry === 'string')) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+/** Detach and normalize one tool's root object without changing the registry schema. */
+export function antigravityToolParameters(parameters, legacy) {
+    const resolved = resolve(parameters, parameters);
+    const root = { ...resolved, type: resolved.type ?? 'object' };
+    if (root.type !== 'object')
+        throw new LlmError('Antigravity tool parameters must be an object schema', 'INVALID_REQUEST');
+    return (legacy ? custom(root) : root);
+}

package/lib/translate/antigravity-thinking.d.ts

@@ -0,0 +1,5 @@
+import type { LlmResolvedModelInfo } from '@deepseek-ai/dsh-llm';
+/** Efforts supported by the known Antigravity runtime families. Unknown models keep upstream defaults. */
+export declare function antigravityReasoning(model: string): LlmResolvedModelInfo['reasoning'];
+/** Build the v1internal thinking config; do not forward arbitrary DSH effort strings. */
+export declare function antigravityThinking(model: string, effort: string | undefined, maxTokens?: number): Record<string, unknown> | undefined;

package/lib/translate/antigravity-thinking.js

@@ -0,0 +1,44 @@
+/** Cloud Code Assist thinking budgets, matched to the runtime model family. */
+import { LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+/** Efforts supported by the known Antigravity runtime families. Unknown models keep upstream defaults. */
+export function antigravityReasoning(model) {
+    const ids = model.startsWith('claude-') ? ['high']
+        : model.startsWith('gpt-oss-') ? ['medium']
+            : model.startsWith('gemini-3.1-pro') || model === 'gemini-pro-agent' ? ['low', 'high']
+                : /^gemini-(?:2\.5|3)/.test(model) ? ['low', 'medium', 'high'] : [];
+    const fixedEffort = /^gemini-.*-(low|medium|high)$/.exec(model)?.[1];
+    const efforts = fixedEffort !== undefined && ids.includes(fixedEffort) ? [fixedEffort] : ids;
+    return efforts.length === 0 ? undefined : {
+        efforts: efforts.map(id => ({ id: ReasoningEffortId(id), name: id[0].toUpperCase() + id.slice(1) })),
+    };
+}
+/** Build the v1internal thinking config; do not forward arbitrary DSH effort strings. */
+export function antigravityThinking(model, effort, maxTokens) {
+    if (effort === undefined)
+        return undefined;
+    const supported = antigravityReasoning(model);
+    if (supported === undefined || effort !== 'off' && !supported.efforts.some(entry => entry.id === effort)) {
+        throw new LlmError(`Antigravity model ${model} does not support reasoning effort ${effort}`, 'UNSUPPORTED_REASONING_EFFORT');
+    }
+    if (effort === 'off')
+        return { includeThoughts: false, thinkingBudget: 0 };
+    // Reference: pi-antigravity src/models/models.ts at 697858c (v1internal wire).
+    let budget;
+    if (model.startsWith('claude-'))
+        budget = 1024;
+    else if (model.startsWith('gpt-oss-'))
+        budget = 8192;
+    else if (model.startsWith('gemini-3.1-pro') || model === 'gemini-pro-agent') {
+        budget = effort === 'high' ? 10001 : 1001;
+    }
+    else if (model.startsWith('gemini-3.5-flash') || model === 'gemini-3-flash-agent') {
+        budget = effort === 'high' ? 10000 : effort === 'medium' ? 4000 : 1000;
+    }
+    else {
+        budget = effort === 'high' ? -1 : effort === 'medium' ? 4000 : 1000;
+    }
+    if (maxTokens !== undefined && budget > 0 && maxTokens <= budget) {
+        throw new LlmError(`Antigravity maxTokens must exceed the thinking budget (${budget}) for ${model}/${effort}`, 'INVALID_REQUEST');
+    }
+    return { includeThoughts: true, thinkingBudget: budget };
+}

package/lib/translate/antigravity.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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 { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+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: Record<string, 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[], model?: string): {
+    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[], model?: string): {
+    role: 'user' | 'model';
+    parts: AntigravityPart[];
+}[];
+/**
+ * Build one v1internal generateContent/streamGenerateContent request.
+ * When forStreaming is true and the model is Claude, caps maxOutputTokens at 64000
+ * to avoid INVALID_ARGUMENT errors.
+ */
+export declare function toAntigravityRequest(options: GenerateOptions, messages: readonly TranslatableMessage[], projectId: string, forStreaming?: boolean): 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 sawThoughtImage;
+    private sawReasoning;
+    private sawToolCall;
+    terminated: boolean;
+    private usage;
+    private readonly images;
+    constructor(attachments?: AttachmentStore, signal?: AbortSignal);
+    private open;
+    private close;
+    private closeAll;
+    private finish;
+    /** Process one decoded Antigravity response frame. */
+    push(event: AntigravityResponseEvent): Promise<StreamChunk[]>;
+}
+/** Consume Antigravity's SSE response into the DSH streaming contract. */
+export declare function streamAntigravity(stream: ReadableStream<Uint8Array>, onActivity?: () => void, attachments?: AttachmentStore, signal?: AbortSignal): AsyncGenerator<StreamChunk>;
+/** Translate a non-stream generateContent response using the same state machine. */
+export declare function parseAntigravityResponse(event: AntigravityResponseEvent, attachments?: AttachmentStore, signal?: AbortSignal): Promise<StreamChunk[]>;