@jsonstudio/llms 0.6.1449 → 0.6.1643

package/dist/conversion/shared/gemini-tool-utils.js

@@ -2,6 +2,26 @@ import { jsonClone } from '../hub/types/json.js';
 function isPlainRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
+function normalizeSchemaMapEntries(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const out = {};
+    for (const entry of value) {
+        if (!isPlainRecord(entry)) {
+            return undefined;
+        }
+        const key = typeof entry.key === 'string' ? entry.key.trim() : '';
+        if (!key) {
+            return undefined;
+        }
+        if (!Object.prototype.hasOwnProperty.call(entry, 'value')) {
+            return undefined;
+        }
+        out[key] = entry.value;
+    }
+    return out;
+}
 function pickBestSchemaVariant(variants) {
     if (!Array.isArray(variants) || variants.length === 0) {
         return { type: 'object', properties: {} };
@@ -45,7 +65,63 @@ function normalizeSchemaTypes(value) {
     const out = {};
     for (const [key, val] of Object.entries(record)) {
         if (key === 'type' && typeof val === 'string') {
-            out[key] = val.toUpperCase();
+            // Antigravity-Manager alignment: keep JSON-Schema-like lowercase types.
+            out[key] = val.trim().toLowerCase();
+            continue;
+        }
+        if (key === 'type' && Array.isArray(val)) {
+            // Antigravity-Manager alignment: Gemini protobuf Schema.type is not repeating.
+            // JSON Schema may use union types like ["string","null"], which triggers:
+            // "Proto field is not repeating, cannot start list."
+            const candidates = val
+                .filter((entry) => typeof entry === 'string')
+                .map((entry) => String(entry).trim().toLowerCase())
+                .filter((entry) => entry && entry !== 'null');
+            const preferred = candidates.includes('string')
+                ? 'string'
+                : candidates.includes('object')
+                    ? 'object'
+                    : candidates.includes('array')
+                        ? 'array'
+                        : candidates.includes('integer')
+                            ? 'integer'
+                            : candidates.includes('number')
+                                ? 'number'
+                                : candidates.includes('boolean')
+                                    ? 'boolean'
+                                    : candidates[0];
+            if (preferred) {
+                out[key] = preferred;
+            }
+            continue;
+        }
+        if (key === 'properties') {
+            const normalizedMap = normalizeSchemaMapEntries(val);
+            if (normalizedMap) {
+                out[key] = normalizeSchemaTypes(normalizedMap);
+                continue;
+            }
+            if (val && typeof val === 'object') {
+                out[key] = normalizeSchemaTypes(val);
+                continue;
+            }
+        }
+        if (key === 'enum' && Array.isArray(val)) {
+            // Antigravity-Manager alignment: Gemini rejects non-string enum values in tool schemas.
+            out[key] = val.map((entry) => {
+                if (typeof entry === 'string')
+                    return entry;
+                if (entry === null)
+                    return 'null';
+                if (typeof entry === 'number' || typeof entry === 'boolean')
+                    return String(entry);
+                try {
+                    return JSON.stringify(entry);
+                }
+                catch {
+                    return String(entry);
+                }
+            });
             continue;
         }
         if ((key === 'properties' || key === 'items') && val && typeof val === 'object') {
@@ -105,6 +181,40 @@ function cloneParameters(value) {
         }
         const cloned = {};
         for (const [key, entry] of Object.entries(value)) {
+            // Antigravity-Manager alignment: some tool pipelines serialize schema maps as [{ key, value }, ...].
+            // Gemini expects `properties` to be an object/map, not a list.
+            if (key === 'properties') {
+                const normalizedMap = normalizeSchemaMapEntries(entry);
+                if (normalizedMap) {
+                    cloned.properties = cloneParameters(normalizedMap);
+                    continue;
+                }
+            }
+            // Antigravity-Manager alignment: Gemini protobuf Schema.type is not repeating.
+            // Drop union array types like ["string","null"] to a single stable type.
+            if (key === 'type' && Array.isArray(entry)) {
+                const candidates = entry
+                    .filter((v) => typeof v === 'string')
+                    .map((v) => String(v).trim().toLowerCase())
+                    .filter((v) => v && v !== 'null');
+                if (candidates.length) {
+                    // Prefer STRING to maximize compatibility.
+                    cloned.type = candidates.includes('string')
+                        ? 'string'
+                        : candidates.includes('object')
+                            ? 'object'
+                            : candidates.includes('array')
+                                ? 'array'
+                                : candidates.includes('integer')
+                                    ? 'integer'
+                                    : candidates.includes('number')
+                                        ? 'number'
+                                        : candidates.includes('boolean')
+                                            ? 'boolean'
+                                            : candidates[0];
+                }
+                continue;
+            }
             // Gemini function_declarations.parameters only support a subset of JSON Schema.
             // Drop meta/unsupported fields that cause INVALID_ARGUMENT, such as $schema/exclusiveMinimum/propertyNames.
             if (typeof key === 'string') {
@@ -132,12 +242,27 @@ function cloneParameters(value) {
                 // Preserve `required` for Gemini validation (align with gcli2api), but still drop additionalProperties.
                 if (key === 'additionalProperties')
                     continue;
+                if (key === 'external_web_access')
+                    continue;
                 // Combinators are handled at the node level above.
                 if (key === 'oneOf' || key === 'anyOf' || key === 'allOf')
                     continue;
             }
             cloned[key] = cloneParameters(entry);
         }
+        // Antigravity-Manager alignment: required must only reference keys present in properties.
+        const propNode = cloned.properties;
+        const reqNode = cloned.required;
+        if (isPlainRecord(propNode) && Array.isArray(reqNode)) {
+            const valid = new Set(Object.keys(propNode));
+            const filtered = reqNode.filter((v) => typeof v === 'string' && valid.has(v));
+            if (filtered.length) {
+                cloned.required = filtered;
+            }
+            else {
+                delete cloned.required;
+            }
+        }
         return cloned;
     }
     return { type: 'object', properties: {} };
@@ -255,11 +380,11 @@ export function buildGeminiToolsFromBridge(defs, options) {
                     // ignore
                 }
                 props.command = {
-                    type: 'STRING',
+                    type: 'string',
                     description: 'Shell command to execute.'
                 };
                 // Keep workdir simple (avoid anyOf string|null patterns).
-                props.workdir = { type: 'STRING', description: 'Working directory.' };
+                props.workdir = { type: 'string', description: 'Working directory.' };
             }
             else {
                 if (!Object.prototype.hasOwnProperty.call(props, 'cmd') && Object.prototype.hasOwnProperty.call(props, 'command')) {
@@ -298,10 +423,10 @@ export function buildGeminiToolsFromBridge(defs, options) {
                 props.text = props.chars;
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'session_id')) {
-                props.session_id = { type: isAntigravity ? 'NUMBER' : 'number' };
+                props.session_id = { type: 'number' };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'chars')) {
-                props.chars = { type: isAntigravity ? 'STRING' : 'string' };
+                props.chars = { type: 'string' };
             }
             params.properties = props;
             try {
@@ -319,25 +444,25 @@ export function buildGeminiToolsFromBridge(defs, options) {
             // - input/instructions/text: historical aliases containing patch text
             if (!Object.prototype.hasOwnProperty.call(props, 'patch')) {
                 props.patch = {
-                    type: isAntigravity ? 'STRING' : 'string',
+                    type: 'string',
                     description: 'Patch text (*** Begin Patch / *** End Patch or GNU unified diff).'
                 };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'input')) {
                 props.input = {
-                    type: isAntigravity ? 'STRING' : 'string',
+                    type: 'string',
                     description: 'Alias of patch (patch text). Prefer patch.'
                 };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'instructions')) {
                 props.instructions = {
-                    type: isAntigravity ? 'STRING' : 'string',
+                    type: 'string',
                     description: 'Alias of patch (patch text). Prefer patch.'
                 };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'text')) {
                 props.text = {
-                    type: isAntigravity ? 'STRING' : 'string',
+                    type: 'string',
                     description: 'Alias of patch (patch text). Prefer patch.'
                 };
             }

package/dist/conversion/shared/text-markup-normalizer.js

@@ -129,8 +129,12 @@ export function extractToolNamespaceXmlBlocksFromText(text) {
     try {
         if (typeof text !== 'string' || !text)
             return null;
-        if (!text.includes('<tool:'))
+        const hasOpenTag = text.includes('<tool:');
+        const hasCloseTag = /<\/\s*tool:\s*[A-Za-z0-9_]+\s*>/i.test(text);
+        const hasToolPrefix = /(?:^|\n)\s*(?:[•*+-]\s*)?tool:[A-Za-z0-9_]+/i.test(text);
+        if (!hasOpenTag && !(hasCloseTag && hasToolPrefix)) {
             return null;
+        }
         const out = [];
         const blockRe = /<\s*tool:([A-Za-z0-9_]+)\s*>([\s\S]*?)<\/\s*tool:\s*\1\s*>/gi;
         let bm;
@@ -211,6 +215,91 @@ export function extractToolNamespaceXmlBlocksFromText(text) {
             }
             out.push({ id: `call_${Math.random().toString(36).slice(2, 10)}`, name: lname, args: argsStr });
         }
+        // Broken variant (seen in the wild):
+        //   tool:exec_command (tool:exec_command)
+        //     <command>...</command>
+        //   </tool:exec_command>
+        //
+        // Best-effort: treat it as an implicit <tool:NAME> open tag.
+        const prefixBlockRe = /(?:^|\n)\s*(?:[•*+-]\s*)?tool:([A-Za-z0-9_]+)[^\n]*\n([\s\S]*?)<\/\s*tool:\s*\1\s*>/gi;
+        let pm;
+        while ((pm = prefixBlockRe.exec(text)) !== null) {
+            const rawName = String(pm[1] || '').trim();
+            const lname = rawName.toLowerCase();
+            if (!lname || !KNOWN_TOOLS.has(lname))
+                continue;
+            const inner = String(pm[2] || '');
+            const argsObj = {};
+            const kvRe = /<\s*([A-Za-z_][A-Za-z0-9_]*)\s*>([\s\S]*?)<\/\s*\1\s*>/g;
+            let km;
+            while ((km = kvRe.exec(inner)) !== null) {
+                const rawKey = String(km[1] || '').trim();
+                const key = normalizeKey(rawKey).toLowerCase();
+                if (!key)
+                    continue;
+                if (key === 'requires_approval')
+                    continue;
+                const rawVal = String(km[2] ?? '');
+                const value = tryParsePrimitiveValue(rawVal);
+                if (lname === 'exec_command' && (key === 'command' || key === 'cmd')) {
+                    const cmd = coerceCommandValueToString(value);
+                    if (cmd.trim().length) {
+                        argsObj.cmd = cmd;
+                        argsObj.command = cmd;
+                    }
+                    continue;
+                }
+                if (lname === 'exec_command' && (key === 'cwd' || key === 'workdir')) {
+                    const wd = String(value ?? rawVal).trim();
+                    if (wd)
+                        argsObj.workdir = wd;
+                    continue;
+                }
+                if (lname === 'write_stdin') {
+                    if (key === 'input' || key === 'data' || key === 'chars' || key === 'text') {
+                        argsObj.chars = rawVal;
+                        continue;
+                    }
+                    if (key === 'session_id') {
+                        const n = Number.parseInt(String(value), 10);
+                        argsObj.session_id = Number.isFinite(n) ? n : value;
+                        continue;
+                    }
+                }
+                if (lname === 'apply_patch' && (key === 'patch' || key === 'input' || key === 'text' || key === 'instructions')) {
+                    const patchText = typeof value === 'string' ? value : rawVal;
+                    if (typeof patchText === 'string' && patchText.trim().length) {
+                        argsObj.patch = patchText;
+                    }
+                    continue;
+                }
+                argsObj[key] = value;
+            }
+            const filtered = filterArgsForTool(lname, argsObj);
+            if (lname === 'exec_command') {
+                const cmd = typeof filtered?.cmd === 'string' ? String(filtered.cmd).trim() : '';
+                if (!cmd)
+                    continue;
+            }
+            if (lname === 'write_stdin') {
+                const sid = filtered?.session_id;
+                if (sid === undefined || sid === null || String(sid).trim().length === 0)
+                    continue;
+            }
+            if (lname === 'apply_patch') {
+                const patchText = typeof filtered?.patch === 'string' ? String(filtered.patch).trim() : '';
+                if (!patchText)
+                    continue;
+            }
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({ id: `call_${Math.random().toString(36).slice(2, 10)}`, name: lname, args: argsStr });
+        }
         return out.length ? out : null;
     }
     catch {

package/dist/conversion/shared/thought-signature-validator.d.ts

@@ -7,7 +7,7 @@
 import type { JsonObject, JsonValue } from '../hub/types/json.js';
 export interface ThoughtSignatureValidationOptions {
     /**
-     * 最小签名长度（默认 10 个字符）
+     * 最小签名长度（默认 50 个字符）
      */
     minLength?: number;
     /**

package/dist/conversion/shared/thought-signature-validator.js

@@ -5,7 +5,8 @@
  * 参考 gcli2api 的实现，确保与上游 API 的兼容性。
  */
 const DEFAULT_OPTIONS = {
-    minLength: 10,
+    // Antigravity-Manager alignment: treat short signatures as noise.
+    minLength: 50,
     allowEmptyThinkingWithSignature: true,
     convertToTextOnFailure: true
 };

package/dist/quota/apikey-reset.d.ts

@@ -0,0 +1,17 @@
+export type DailyResetParseResult = {
+    ok: true;
+    kind: 'local' | 'utc';
+    hour: number;
+    minute: number;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseDailyResetTime(input: string | null | undefined): DailyResetParseResult;
+export declare function computeNextDailyResetAtMs(args: {
+    nowMs: number;
+    resetTime?: string | null;
+}): {
+    resetAtMs: number;
+    resetTimeNormalized: string;
+};

package/dist/quota/apikey-reset.js

@@ -0,0 +1,43 @@
+function pad2(n) {
+    return String(n).padStart(2, '0');
+}
+export function parseDailyResetTime(input) {
+    const raw = typeof input === 'string' ? input.trim() : '';
+    const value = raw || '12:00';
+    const isUtc = value.toUpperCase().endsWith('Z');
+    const base = isUtc ? value.slice(0, -1) : value;
+    const m = base.match(/^(\d{1,2}):(\d{2})$/);
+    if (!m) {
+        return { ok: false, error: `invalid reset time format: ${value}` };
+    }
+    const hour = Number(m[1]);
+    const minute = Number(m[2]);
+    if (!Number.isFinite(hour) || !Number.isFinite(minute) || hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+        return { ok: false, error: `invalid reset time value: ${value}` };
+    }
+    return { ok: true, kind: isUtc ? 'utc' : 'local', hour, minute };
+}
+export function computeNextDailyResetAtMs(args) {
+    const parsed = parseDailyResetTime(args.resetTime);
+    const fallback = { ok: true, kind: 'local', hour: 12, minute: 0 };
+    const resolved = parsed.ok ? parsed : fallback;
+    const kind = resolved.kind;
+    const hour = resolved.hour;
+    const minute = resolved.minute;
+    const resetTimeNormalized = `${pad2(hour)}:${pad2(minute)}${kind === 'utc' ? 'Z' : ''}`;
+    const now = new Date(args.nowMs);
+    let candidate;
+    if (kind === 'utc') {
+        candidate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), hour, minute, 0, 0));
+        if (candidate.getTime() <= args.nowMs) {
+            candidate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1, hour, minute, 0, 0));
+        }
+    }
+    else {
+        candidate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute, 0, 0);
+        if (candidate.getTime() <= args.nowMs) {
+            candidate = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, hour, minute, 0, 0);
+        }
+    }
+    return { resetAtMs: candidate.getTime(), resetTimeNormalized };
+}

package/dist/quota/index.d.ts

@@ -0,0 +1,2 @@
+export type { QuotaReason, QuotaAuthType, QuotaAuthIssue, StaticQuotaConfig, QuotaState, QuotaStore, QuotaStoreSnapshot } from './types.js';
+export { QuotaManager } from './quota-manager.js';

package/dist/quota/index.js

@@ -0,0 +1 @@
+export { QuotaManager } from './quota-manager.js';

package/dist/quota/quota-manager.d.ts

@@ -0,0 +1,44 @@
+import type { ProviderErrorEvent, ProviderSuccessEvent, ProviderQuotaView } from '../router/virtual-router/types.js';
+import type { QuotaState, QuotaStore, StaticQuotaConfig } from './types.js';
+export declare class QuotaManager {
+    private readonly staticConfigs;
+    private readonly states;
+    private readonly store;
+    private persistTimer;
+    private dirty;
+    constructor(options?: {
+        store?: QuotaStore | null;
+    });
+    hydrateFromStore(): Promise<void>;
+    registerProviderStaticConfig(providerKey: string, cfg: StaticQuotaConfig): void;
+    ensureProvider(providerKey: string): QuotaState;
+    disableProvider(options: {
+        providerKey: string;
+        mode: 'cooldown' | 'blacklist';
+        durationMs: number;
+        reason?: string;
+    }): void;
+    recoverProvider(providerKey: string): void;
+    resetProvider(providerKey: string): void;
+    onProviderError(ev: ProviderErrorEvent): void;
+    onProviderSuccess(ev: ProviderSuccessEvent): void;
+    /**
+     * External quota snapshot ingestion hook (host-driven).
+     * This API is intentionally small: the host adapter translates provider-specific
+     * quota responses into a normalized per-providerKey inPool/cooldown/blacklist update.
+     */
+    updateProviderPoolState(options: {
+        providerKey: string;
+        inPool: boolean;
+        reason?: string | null;
+        cooldownUntil?: number | null;
+        blacklistUntil?: number | null;
+    }): void;
+    getQuotaView(): ProviderQuotaView;
+    getSnapshot(): {
+        updatedAtMs: number;
+        providers: Record<string, QuotaState>;
+    };
+    private markDirty;
+    persistNow(): Promise<void>;
+}