@jsonstudio/llms 0.6.1449 → 0.6.1643

package/dist/servertool/handlers/antigravity-thought-signature-bootstrap.js

@@ -0,0 +1,201 @@
+import { registerServerToolHandler } from '../registry.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
+import { cloneJson } from '../server-side-tools.js';
+const FLOW_ID = 'antigravity_thought_signature_bootstrap';
+function readProviderKey(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object') {
+        return '';
+    }
+    const raw = adapterContext.providerKey ?? adapterContext.runtimeKey ?? adapterContext.providerId;
+    return typeof raw === 'string' ? raw.trim() : '';
+}
+function isAntigravityFamily(providerKey) {
+    const lowered = providerKey.toLowerCase();
+    return lowered.startsWith('antigravity.') || lowered.startsWith('gemini-cli.');
+}
+function readErrorInfo(base) {
+    const err = base.error;
+    if (!err || typeof err !== 'object' || Array.isArray(err)) {
+        return null;
+    }
+    const codeRaw = err.code;
+    const msgRaw = err.message;
+    const statusRaw = err.status ?? err.statusCode;
+    const code = typeof codeRaw === 'string' ? codeRaw.trim() : typeof codeRaw === 'number' ? String(codeRaw) : undefined;
+    const message = typeof msgRaw === 'string' ? msgRaw.trim() : undefined;
+    const status = typeof statusRaw === 'number' && Number.isFinite(statusRaw)
+        ? Math.floor(statusRaw)
+        : typeof code === 'string' && /^HTTP_\d{3}$/i.test(code)
+            ? Number(code.split('_')[1])
+            : typeof code === 'string' && /^\d{3}$/.test(code)
+                ? Number(code)
+                : undefined;
+    return { ...(status ? { status } : {}), ...(code ? { code } : {}), ...(message ? { message } : {}) };
+}
+function isSignatureInvalidError(error) {
+    const code = (error.code || '').toLowerCase();
+    if (code.includes('signature')) {
+        return true;
+    }
+    const msg = (error.message || '').toLowerCase();
+    return msg.includes('signature') && (msg.includes('invalid') || msg.includes('corrupt') || msg.includes('validator'));
+}
+function shouldTriggerBootstrap(error) {
+    // One-shot bootstrap trigger:
+    // - Always attempt once on 429 (may be quota OR signature validator; one-shot prevents loops).
+    // - Also attempt on 400 when we can confidently classify as signature invalid/missing.
+    if (error.status === 429)
+        return true;
+    if (error.status === 400 && isSignatureInvalidError(error))
+        return true;
+    return false;
+}
+function buildClockToolSchema() {
+    // Keep this schema aligned with docs/SERVERTOOL_CLOCK_DESIGN.md + chat-process injection.
+    return {
+        type: 'function',
+        function: {
+            name: 'clock',
+            description: 'Time + Alarm for this session. Use get/schedule/list/cancel/clear. Scheduled reminders will be injected into future requests.',
+            strict: true,
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['get', 'schedule', 'list', 'cancel', 'clear'],
+                        description: 'Get current time, or schedule/list/cancel/clear session-scoped reminders.'
+                    },
+                    items: {
+                        type: 'array',
+                        description: 'For schedule: list of reminders to add.',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                dueAt: {
+                                    type: 'string',
+                                    description: 'ISO8601 datetime with timezone (e.g. 2026-01-21T20:30:00-08:00).'
+                                },
+                                task: {
+                                    type: 'string',
+                                    description: 'Reminder text (should include which tool to use and what to do).'
+                                },
+                                tool: {
+                                    type: 'string',
+                                    description: 'Optional suggested tool name (hint only).'
+                                },
+                                arguments: {
+                                    type: 'string',
+                                    description: 'Optional suggested tool arguments as a JSON string (hint only). Use "{}" when unsure.'
+                                }
+                            },
+                            required: ['dueAt', 'task', 'tool', 'arguments'],
+                            additionalProperties: false
+                        }
+                    },
+                    taskId: {
+                        type: 'string',
+                        description: 'For cancel: taskId to remove.'
+                    }
+                },
+                required: ['action', 'items', 'taskId'],
+                additionalProperties: false
+            }
+        }
+    };
+}
+function ensureClockTool(tools) {
+    const list = Array.isArray(tools) ? cloneJson(tools) : [];
+    const hasClock = list.some((tool) => {
+        const fn = tool && typeof tool === 'object' && !Array.isArray(tool) ? tool.function : undefined;
+        const name = fn && typeof fn === 'object' && typeof fn.name === 'string' ? String(fn.name) : '';
+        return name.trim() === 'clock';
+    });
+    if (hasClock) {
+        return list;
+    }
+    return [...list, buildClockToolSchema()];
+}
+const BOOTSTRAP_USER_PROMPT = '请先调用 `clock` 工具并传入 `{\"action\":\"get\",\"items\":[],\"taskId\":\"\"}` 获取当前时间；' +
+    '得到工具返回后只需回复 `OK`（不要调用其它工具）。';
+const handler = async (ctx) => {
+    if (!ctx.capabilities.reenterPipeline) {
+        return null;
+    }
+    if (ctx.providerProtocol !== 'gemini-chat') {
+        return null;
+    }
+    const providerKey = readProviderKey(ctx.adapterContext);
+    if (!providerKey || !isAntigravityFamily(providerKey)) {
+        return null;
+    }
+    const rt = readRuntimeMetadata(ctx.adapterContext);
+    if (rt?.serverToolFollowup === true) {
+        return null;
+    }
+    if (rt?.antigravityThoughtSignatureBootstrapAttempted === true) {
+        return null;
+    }
+    const error = readErrorInfo(ctx.base);
+    if (!error || !shouldTriggerBootstrap(error)) {
+        return null;
+    }
+    const captured = ctx.adapterContext?.capturedChatRequest;
+    const seed = extractCapturedChatSeed(captured);
+    if (!seed) {
+        return null;
+    }
+    // Preflight bootstrap request:
+    // - Avoid any historical tool calls so Gemini can emit a fresh thoughtSignature.
+    // - Keep the FIRST user message identical to the original request to preserve derived session_id.
+    const originalMessages = Array.isArray(seed.messages) ? cloneJson(seed.messages) : [];
+    const firstUser = originalMessages.find((m) => {
+        const role = typeof m?.role === 'string' ? String(m.role).toLowerCase() : '';
+        return role === 'user';
+    });
+    if (!firstUser) {
+        return null;
+    }
+    const messages = [cloneJson(firstUser), { role: 'user', content: BOOTSTRAP_USER_PROMPT }];
+    const parameters = {
+        ...(seed.parameters && typeof seed.parameters === 'object' && !Array.isArray(seed.parameters)
+            ? cloneJson(seed.parameters)
+            : {})
+    };
+    // Gemini toolConfig forcing: request the model to emit a clock call first, before any other tools.
+    parameters.tool_config = {
+        functionCallingConfig: {
+            mode: 'ANY',
+            allowedFunctionNames: ['clock']
+        }
+    };
+    const followupPayload = {
+        ...(seed.model ? { model: seed.model } : {}),
+        messages,
+        tools: ensureClockTool([]),
+        ...(Object.keys(parameters).length ? { parameters } : {})
+    };
+    const followupMetadata = {
+        __shadowCompareForcedProviderKey: providerKey
+    };
+    const followupRt = ensureRuntimeMetadata(followupMetadata);
+    followupRt.antigravityThoughtSignatureBootstrap = true;
+    followupRt.antigravityThoughtSignatureBootstrapAttempted = true;
+    return {
+        flowId: FLOW_ID,
+        finalize: async () => ({
+            chatResponse: ctx.base,
+            execution: {
+                flowId: FLOW_ID,
+                followup: {
+                    requestIdSuffix: ':antigravity_ts_bootstrap',
+                    entryEndpoint: ctx.entryEndpoint,
+                    payload: followupPayload,
+                    metadata: followupMetadata
+                }
+            }
+        })
+    };
+};
+registerServerToolHandler(FLOW_ID, handler, { trigger: 'auto' });

package/dist/servertool/handlers/clock-auto.js

@@ -2,6 +2,7 @@ import { registerServerToolHandler } from '../registry.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
 import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
 import { findNextUndeliveredDueAtMs, listClockTasks, resolveClockConfig, startClockDaemonIfNeeded } from '../clock/task-store.js';
+import { nowMs } from '../clock/state.js';
 import { logClock } from '../clock/log.js';
 const FLOW_ID = 'clock_hold_flow';
 function resolveClientConnectionState(value) {
@@ -14,6 +15,23 @@ function resolveClientConnectionState(value) {
     }
     return { disconnected: record.disconnected };
 }
+function clientWantsStreaming(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return false;
+    }
+    const record = adapterContext;
+    if (record.stream === true) {
+        return true;
+    }
+    const clientHeaders = record.clientHeaders;
+    if (clientHeaders && typeof clientHeaders === 'object' && !Array.isArray(clientHeaders)) {
+        const accept = clientHeaders.accept;
+        if (typeof accept === 'string' && accept.toLowerCase().includes('text/event-stream')) {
+            return true;
+        }
+    }
+    return false;
+}
 function isStopFinishReason(base) {
     if (!base || typeof base !== 'object' || Array.isArray(base)) {
         return false;
@@ -109,30 +127,47 @@ const handler = async (ctx) => {
         return null;
     }
     await startClockDaemonIfNeeded(clockConfig);
+    // IMPORTANT: clock hold requires a long-lived client connection.
+    // - Streaming/SSE clients: ok to hold (keepalive is handled by host SSE bridge).
+    // - Non-streaming/JSON clients: only hold when explicitly enabled via config,
+    //   and only within a small max window (holdMaxMs).
+    const wantsStream = clientWantsStreaming(ctx.adapterContext);
+    if (!wantsStream && clockConfig.holdNonStreaming !== true) {
+        return null;
+    }
     const seed = extractCapturedChatSeed(record.capturedChatRequest);
     if (!seed) {
         return null;
     }
     const tasks = await listClockTasks(sessionId, clockConfig);
-    const at = Date.now();
+    const at = nowMs();
     const nextDueAtMs = findNextUndeliveredDueAtMs(tasks, at);
     if (!nextDueAtMs) {
         return null;
     }
     // Wait until the "due window" is reached (now >= dueAt - dueWindowMs).
     const thresholdMs = nextDueAtMs - clockConfig.dueWindowMs;
+    // Important: if we're already inside the due window, do NOT auto-followup in the current request
+    // (prevents same-request loops; the reminder will be injected on the next request).
+    if (at >= thresholdMs) {
+        return null;
+    }
+    const remainingMs = thresholdMs - at;
+    if (clockConfig.holdMaxMs >= 0 && remainingMs > clockConfig.holdMaxMs) {
+        return null;
+    }
     logClock('hold_start', { sessionId, nextDueAtMs, thresholdMs });
-    while (Date.now() < thresholdMs) {
+    while (nowMs() < thresholdMs) {
         const state = resolveClientConnectionState(ctx.adapterContext.clientConnectionState);
         if (state?.disconnected === true) {
             return null;
         }
-        const remaining = thresholdMs - Date.now();
+        const remaining = thresholdMs - nowMs();
         await sleep(computeHoldSleepMs(remaining));
         // Best-effort: if tasks were cleared/cancelled while holding, stop holding.
         try {
             const refreshed = await listClockTasks(sessionId, clockConfig);
-            const refreshedNext = findNextUndeliveredDueAtMs(refreshed, Date.now());
+            const refreshedNext = findNextUndeliveredDueAtMs(refreshed, nowMs());
             if (!refreshedNext) {
                 return null;
             }

package/dist/servertool/handlers/clock.js

@@ -1,10 +1,63 @@
 import { registerServerToolHandler } from '../registry.js';
 import { cloneJson } from '../server-side-tools.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
-import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
 import { cancelClockTask, clearClockTasks, listClockTasks, resolveClockConfig, parseDueAtMs, scheduleClockTasks, startClockDaemonIfNeeded } from '../clock/task-store.js';
+import { getClockTimeSnapshot } from '../clock/ntp.js';
+import { nowMs } from '../clock/state.js';
 import { logClock } from '../clock/log.js';
 const FLOW_ID = 'clock_flow';
+function extractAssistantMessageFromChatLike(chatResponse) {
+    if (!chatResponse || typeof chatResponse !== 'object') {
+        return null;
+    }
+    const choices = Array.isArray(chatResponse.choices) ? chatResponse.choices : [];
+    if (!choices.length) {
+        return null;
+    }
+    const first = choices[0];
+    if (!first || typeof first !== 'object' || Array.isArray(first)) {
+        return null;
+    }
+    const message = first.message;
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return null;
+    }
+    const role = typeof message.role === 'string' ? String(message.role).toLowerCase() : '';
+    if (role && role !== 'assistant') {
+        return null;
+    }
+    return cloneJson(message);
+}
+function buildToolMessagesFromToolOutputs(chatResponse) {
+    const outputs = Array.isArray(chatResponse.tool_outputs) ? chatResponse.tool_outputs : [];
+    const out = [];
+    for (const entry of outputs) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const toolCallId = typeof entry.tool_call_id === 'string' ? String(entry.tool_call_id) : '';
+        if (!toolCallId)
+            continue;
+        const name = typeof entry.name === 'string' && String(entry.name).trim()
+            ? String(entry.name).trim()
+            : 'tool';
+        const rawContent = entry.content;
+        let contentText;
+        if (typeof rawContent === 'string') {
+            contentText = rawContent;
+        }
+        else {
+            try {
+                contentText = JSON.stringify(rawContent ?? {});
+            }
+            catch {
+                contentText = String(rawContent ?? '');
+            }
+        }
+        out.push({ role: 'tool', tool_call_id: toolCallId, name, content: contentText });
+    }
+    return out;
+}
 function parseToolArguments(toolCall) {
     if (!toolCall.arguments || typeof toolCall.arguments !== 'string') {
         return {};
@@ -59,7 +112,7 @@ function asPlainObject(value) {
 }
 function normalizeAction(value) {
     const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
-    if (raw === 'list' || raw === 'cancel' || raw === 'clear' || raw === 'schedule') {
+    if (raw === 'get' || raw === 'list' || raw === 'cancel' || raw === 'clear' || raw === 'schedule') {
         return raw;
     }
     return 'schedule';
@@ -147,6 +200,12 @@ const handler = async (ctx) => {
                 const patched = injectClockToolOutput(ctx.base, toolCall, payload);
                 const seed = extractCapturedChatSeed(ctx.adapterContext?.capturedChatRequest);
                 const canFollowup = Boolean(seed);
+                const bootstrapActive = rt?.antigravityThoughtSignatureBootstrap === true;
+                const forcedProviderKey = bootstrapActive &&
+                    typeof ctx.adapterContext.providerKey === 'string' &&
+                    String(ctx.adapterContext.providerKey).trim()
+                    ? String(ctx.adapterContext.providerKey).trim()
+                    : '';
                 return {
                     chatResponse: patched,
                     execution: {
@@ -156,12 +215,46 @@ const handler = async (ctx) => {
                                 followup: {
                                     requestIdSuffix: ':clock_followup',
                                     entryEndpoint: ctx.entryEndpoint,
-                                    injection: {
-                                        ops: [
-                                            { op: 'append_assistant_message', required: true },
-                                            { op: 'append_tool_messages_from_tool_outputs', required: true }
-                                        ]
-                                    }
+                                    ...(bootstrapActive && seed
+                                        ? {
+                                            payload: (() => {
+                                                const messages = Array.isArray(seed.messages) ? cloneJson(seed.messages) : [];
+                                                const assistant = extractAssistantMessageFromChatLike(ctx.base);
+                                                if (assistant) {
+                                                    messages.push(assistant);
+                                                }
+                                                messages.push(...buildToolMessagesFromToolOutputs(patched));
+                                                const params = seed.parameters && typeof seed.parameters === 'object' && !Array.isArray(seed.parameters)
+                                                    ? { ...seed.parameters }
+                                                    : {};
+                                                // Bootstrap-only: the first hop forces tool_config=clock; the second hop must clear it
+                                                // so the model can either answer or call other tools normally.
+                                                delete params.tool_config;
+                                                return {
+                                                    ...(seed.model ? { model: seed.model } : {}),
+                                                    messages,
+                                                    ...(Array.isArray(seed.tools) ? { tools: cloneJson(seed.tools) } : {}),
+                                                    ...(Object.keys(params).length ? { parameters: params } : {})
+                                                };
+                                            })(),
+                                            metadata: (() => {
+                                                const meta = {};
+                                                if (forcedProviderKey) {
+                                                    meta.__shadowCompareForcedProviderKey = forcedProviderKey;
+                                                }
+                                                const runtime = ensureRuntimeMetadata(meta);
+                                                runtime.antigravityThoughtSignatureBootstrapAttempted = true;
+                                                return meta;
+                                            })()
+                                        }
+                                        : {
+                                            injection: {
+                                                ops: [
+                                                    { op: 'append_assistant_message', required: true },
+                                                    { op: 'append_tool_messages_from_tool_outputs', required: true }
+                                                ]
+                                            }
+                                        })
                                 }
                             }
                             : {})
@@ -170,23 +263,47 @@ const handler = async (ctx) => {
             }
         };
     };
-    if (!sessionId) {
-        logClock('missing_session', { action });
+    if (!clockConfig) {
+        logClock('disabled', { action, hasSessionId: true });
         return respond({
             ok: false,
             action,
-            message: 'clock requires sessionId (x-session-id header or metadata.sessionId).'
+            message: 'clock tool is not enabled (virtualrouter.clock.enabled=true required).'
         });
     }
-    if (!clockConfig) {
-        logClock('disabled', { action, hasSessionId: true });
+    await startClockDaemonIfNeeded(clockConfig);
+    if (action === 'get') {
+        try {
+            const snapshot = await getClockTimeSnapshot();
+            logClock('get', { hasSessionId: Boolean(sessionId) });
+            return respond({
+                ok: true,
+                action,
+                active: true,
+                nowMs: snapshot.nowMs,
+                utc: snapshot.utc,
+                local: snapshot.local,
+                timezone: snapshot.timezone,
+                ntp: snapshot.ntp
+            });
+        }
+        catch (err) {
+            logClock('get_error', { message: String(err?.message || err || '') });
+            return respond({
+                ok: false,
+                action,
+                message: `clock.get failed: ${String(err?.message || err || 'unknown')}`
+            });
+        }
+    }
+    if (!sessionId) {
+        logClock('missing_session', { action });
         return respond({
             ok: false,
             action,
-            message: 'clock tool is not enabled (virtualrouter.clock.enabled=true required).'
+            message: 'clock requires sessionId (x-session-id header or metadata.sessionId).'
         });
     }
-    await startClockDaemonIfNeeded(clockConfig);
     if (action === 'list') {
         const items = await listClockTasks(sessionId, clockConfig);
         logClock('list', { sessionId, count: items.length });
@@ -212,7 +329,19 @@ const handler = async (ctx) => {
         logClock('schedule_invalid', { sessionId, message: normalized.message ?? 'invalid schedule items' });
         return respond({ ok: false, action, message: normalized.message ?? 'invalid schedule items' });
     }
-    const scheduled = await scheduleClockTasks(sessionId, normalized.items, clockConfig);
+    const at = nowMs();
+    const guardedItems = normalized.items.map((item) => {
+        if (!item || typeof item !== 'object')
+            return item;
+        if (!Number.isFinite(item.dueAtMs))
+            return item;
+        // When dueAt is already within the trigger window, do NOT allow same-request injection.
+        if (item.dueAtMs <= at + clockConfig.dueWindowMs) {
+            return { ...item, notBeforeRequestId: ctx.requestId };
+        }
+        return item;
+    });
+    const scheduled = await scheduleClockTasks(sessionId, guardedItems, clockConfig);
     logClock('schedule', { sessionId, count: scheduled.length });
     return respond({
         ok: true,

package/dist/servertool/handlers/followup-request-builder.js

@@ -175,6 +175,7 @@ function injectVisionSummaryIntoMessages(source, summary) {
                     : '';
                 if (typeValue.includes('image')) {
                     removed = true;
+                    nextParts.push({ type: 'text', text: '[Image omitted]' });
                     continue;
                 }
             }
@@ -248,6 +249,85 @@ function injectSystemTextIntoMessages(source, text) {
     messages.splice(insertAt, 0, sys);
     return messages;
 }
+function buildStandardFollowupTools() {
+    // Keep this list minimal and stable. Used only as a best-effort fallback when a followup hop
+    // would otherwise have no tools at all (which can cause tool-based clients to "break" mid-session).
+    return [
+        {
+            type: 'function',
+            function: {
+                name: 'shell',
+                description: 'Runs a shell command and returns its output.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        command: { oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }] },
+                        workdir: { type: 'string' }
+                    },
+                    required: ['command'],
+                    additionalProperties: false
+                }
+            }
+        },
+        {
+            type: 'function',
+            function: {
+                name: 'exec_command',
+                description: 'Execute a command in a PTY and return output.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        cmd: { type: 'string' },
+                        workdir: { type: 'string' },
+                        timeout_ms: { type: 'number' },
+                        max_output_tokens: { type: 'number' },
+                        yield_time_ms: { type: 'number' }
+                    },
+                    required: ['cmd'],
+                    additionalProperties: false
+                }
+            }
+        },
+        {
+            type: 'function',
+            function: {
+                name: 'apply_patch',
+                description: 'Apply a patch to repository files.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        patch: { type: 'string' }
+                    },
+                    required: ['patch'],
+                    additionalProperties: false
+                }
+            }
+        }
+    ];
+}
+function ensureStandardToolsIfMissing(current) {
+    const existing = Array.isArray(current) ? cloneJson(current) : [];
+    const seen = new Set();
+    for (const tool of existing) {
+        if (!tool || typeof tool !== 'object' || Array.isArray(tool))
+            continue;
+        const fn = tool.function;
+        const name = fn && typeof fn === 'object' && typeof fn.name === 'string' ? String(fn.name).trim() : '';
+        if (name)
+            seen.add(name);
+    }
+    for (const tool of buildStandardFollowupTools()) {
+        const fn = tool.function;
+        const name = fn && typeof fn === 'object' && typeof fn.name === 'string' ? String(fn.name).trim() : '';
+        if (!name)
+            continue;
+        if (seen.has(name))
+            continue;
+        existing.push(tool);
+        seen.add(name);
+    }
+    return existing;
+}
 /**
  * Build a canonical followup request body from injection ops.
  *
@@ -281,6 +361,10 @@ export function buildServerToolFollowupChatPayloadFromInjection(args) {
             // No-op: tools are preserved by default. Kept for backward compatibility.
             continue;
         }
+        if (op.op === 'ensure_standard_tools') {
+            tools = ensureStandardToolsIfMissing(tools);
+            continue;
+        }
         if (op.op === 'trim_openai_messages') {
             const maxNonSystemMessages = typeof op.maxNonSystemMessages === 'number'
                 ? op.maxNonSystemMessages

package/dist/servertool/handlers/stop-message-auto.js

@@ -178,7 +178,7 @@ const handler = async (ctx) => {
                     injection: {
                         ops: [
                             { op: 'append_assistant_message', required: false },
-                            { op: 'preserve_tools' },
+                            { op: 'ensure_standard_tools' },
                             { op: 'append_user_text', text }
                         ]
                     },

package/dist/servertool/server-side-tools.d.ts

@@ -2,6 +2,7 @@ import type { JsonObject } from '../conversion/hub/types/json.js';
 import type { ServerSideToolEngineOptions, ServerSideToolEngineResult, ToolCall } from './types.js';
 import './handlers/iflow-model-error-retry.js';
 import './handlers/gemini-empty-reply-continue.js';
+import './handlers/antigravity-thought-signature-bootstrap.js';
 import './handlers/stop-message-auto.js';
 import './handlers/clock.js';
 import './handlers/clock-auto.js';

package/dist/servertool/server-side-tools.js

@@ -4,6 +4,7 @@ import { executeWebSearchBackendPlan } from './handlers/web-search.js';
 import { executeVisionBackendPlan } from './handlers/vision.js';
 import './handlers/iflow-model-error-retry.js';
 import './handlers/gemini-empty-reply-continue.js';
+import './handlers/antigravity-thought-signature-bootstrap.js';
 import './handlers/stop-message-auto.js';
 import './handlers/clock.js';
 import './handlers/clock-auto.js';

package/dist/servertool/types.d.ts

@@ -51,6 +51,8 @@ export interface ServerSideToolEngineOptions {
 }
 export type ServerToolFollowupInjectionOp = {
     op: 'preserve_tools';
+} | {
+    op: 'ensure_standard_tools';
 } | {
     op: 'append_assistant_message';
     required?: boolean;