@jsonstudio/llms 0.6.954 → 0.6.1164

package/dist/servertool/engine.js

@@ -3,6 +3,9 @@ import { ProviderProtocolError } from '../conversion/shared/errors.js';
 import { createHash } from 'node:crypto';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateSync } from '../router/virtual-router/sticky-session-store.js';
 import { deserializeRoutingInstructionState, serializeRoutingInstructionState } from '../router/virtual-router/routing-instructions.js';
+import { applyHubFollowupPolicyShadow } from './followup-shadow.js';
+import { buildServerToolFollowupChatPayloadFromInjection } from './handlers/followup-request-builder.js';
+import { findNextUndeliveredDueAtMs, listClockTasks, normalizeClockConfig } from './clock/task-store.js';
 function parseTimeoutMs(raw, fallback) {
     const n = typeof raw === 'string' ? Number(raw.trim()) : typeof raw === 'number' ? raw : NaN;
     if (!Number.isFinite(n) || n <= 0) {
@@ -153,8 +156,108 @@ function isEmptyClientResponsePayload(payload) {
     }
     return true;
 }
+function isStopFinishReasonWithoutToolCalls(base) {
+    if (!base || typeof base !== 'object' || Array.isArray(base)) {
+        return false;
+    }
+    const payload = base;
+    const choicesRaw = payload.choices;
+    if (Array.isArray(choicesRaw) && choicesRaw.length) {
+        const first = choicesRaw[0];
+        if (!first || typeof first !== 'object' || Array.isArray(first)) {
+            return false;
+        }
+        const finishReasonRaw = first.finish_reason;
+        const finishReason = typeof finishReasonRaw === 'string' && finishReasonRaw.trim()
+            ? finishReasonRaw.trim().toLowerCase()
+            : '';
+        if (!finishReason || finishReason === 'tool_calls') {
+            return false;
+        }
+        if (finishReason !== 'stop' && finishReason !== 'length') {
+            return false;
+        }
+        const message = first.message &&
+            typeof first.message === 'object' &&
+            !Array.isArray(first.message)
+            ? first.message
+            : null;
+        if (!message) {
+            return false;
+        }
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        if (toolCalls.length > 0) {
+            return false;
+        }
+        return true;
+    }
+    // Responses-like: completed without required_action generally counts as stop.
+    const statusRaw = typeof payload.status === 'string' ? payload.status.trim().toLowerCase() : '';
+    if (statusRaw && statusRaw !== 'completed') {
+        return false;
+    }
+    if (payload.required_action && typeof payload.required_action === 'object') {
+        return false;
+    }
+    return true;
+}
+async function shouldDisableServerToolTimeoutForClockHold(args) {
+    // Only relevant for stop/length responses: clock_auto may hold indefinitely.
+    if (!isStopFinishReasonWithoutToolCalls(args.chat)) {
+        return false;
+    }
+    const record = args.adapterContext;
+    const clockConfig = normalizeClockConfig(record.clock);
+    if (!clockConfig) {
+        return false;
+    }
+    const sessionId = typeof record.sessionId === 'string' ? record.sessionId.trim() : '';
+    if (!sessionId) {
+        return false;
+    }
+    // If already within due window, clock_auto won't need long hold.
+    try {
+        const tasks = await listClockTasks(sessionId, clockConfig);
+        const at = Date.now();
+        const nextDueAtMs = findNextUndeliveredDueAtMs(tasks, at);
+        if (!nextDueAtMs) {
+            return false;
+        }
+        const thresholdMs = nextDueAtMs - clockConfig.dueWindowMs;
+        if (thresholdMs <= at) {
+            return false;
+        }
+        // Only disable when the wait exceeds current timeout.
+        if (args.serverToolTimeoutMs > 0 && thresholdMs - at <= args.serverToolTimeoutMs) {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function runServerToolOrchestration(options) {
+    const YELLOW = '\x1b[38;5;214m';
+    const RESET = '\x1b[0m';
+    const logProgress = (step, total, message, extra) => {
+        try {
+            // eslint-disable-next-line no-console
+            console.log(`${YELLOW}[servertool][progress ${step}/${total}] requestId=${options.requestId} ${message}` +
+                (extra ? ` ${JSON.stringify(extra)}` : '') +
+                RESET);
+        }
+        catch {
+            /* best-effort logging */
+        }
+    };
     const serverToolTimeoutMs = resolveServerToolTimeoutMs();
+    const shouldDisableTimeout = await shouldDisableServerToolTimeoutForClockHold({
+        chat: options.chat,
+        adapterContext: options.adapterContext,
+        serverToolTimeoutMs
+    });
+    const effectiveServerToolTimeoutMs = shouldDisableTimeout ? 0 : serverToolTimeoutMs;
     const followupTimeoutMs = resolveServerToolFollowupTimeoutMs(serverToolTimeoutMs);
     const engineOptions = {
         chatResponse: options.chat,
@@ -165,10 +268,10 @@ export async function runServerToolOrchestration(options) {
         providerInvoker: options.providerInvoker,
         reenterPipeline: options.reenterPipeline
     };
-    const engineResult = await withTimeout(runServerSideToolEngine(engineOptions), serverToolTimeoutMs, () => createServerToolTimeoutError({
+    const engineResult = await withTimeout(runServerSideToolEngine(engineOptions), effectiveServerToolTimeoutMs, () => createServerToolTimeoutError({
         requestId: options.requestId,
         phase: 'engine',
-        timeoutMs: serverToolTimeoutMs
+        timeoutMs: effectiveServerToolTimeoutMs || serverToolTimeoutMs
     }));
     if (engineResult.mode === 'passthrough' || !engineResult.execution) {
         return {
@@ -176,7 +279,11 @@ export async function runServerToolOrchestration(options) {
             executed: false
         };
     }
+    const flowId = engineResult.execution.flowId ?? 'unknown';
+    const totalSteps = 5;
+    logProgress(1, totalSteps, 'matched', { flowId });
     if (!engineResult.execution.followup || !options.reenterPipeline) {
+        logProgress(5, totalSteps, 'completed (no followup)', { flowId });
         return {
             chat: engineResult.finalChatResponse,
             executed: true,
@@ -193,8 +300,45 @@ export async function runServerToolOrchestration(options) {
     const applyAutoLimit = isAutoStopMessage || isErrorAutoFlow || isGeminiEmptyReplyContinue || isApplyPatchGuard || isExecCommandGuard;
     // ServerTool followups must not inherit or inject any routeHint; always route fresh.
     const preserveRouteHint = false;
-    const loopState = buildServerToolLoopState(options.adapterContext, engineResult.execution.flowId, engineResult.execution.followup.payload);
+    const followupPlan = engineResult.execution.followup;
+    const followupEntryEndpoint = engineResult.execution.followup.entryEndpoint ||
+        options.entryEndpoint ||
+        '/v1/chat/completions';
+    const followupPayloadRaw = (() => {
+        if (followupPlan &&
+            typeof followupPlan === 'object' &&
+            !Array.isArray(followupPlan) &&
+            Object.prototype.hasOwnProperty.call(followupPlan, 'payload')) {
+            const candidate = followupPlan.payload;
+            return candidate && typeof candidate === 'object' && !Array.isArray(candidate) ? candidate : null;
+        }
+        if (followupPlan &&
+            typeof followupPlan === 'object' &&
+            !Array.isArray(followupPlan) &&
+            Object.prototype.hasOwnProperty.call(followupPlan, 'injection')) {
+            const injection = followupPlan.injection;
+            if (!injection || typeof injection !== 'object' || Array.isArray(injection)) {
+                return null;
+            }
+            return buildServerToolFollowupChatPayloadFromInjection({
+                adapterContext: options.adapterContext,
+                chatResponse: engineResult.finalChatResponse,
+                injection: injection
+            });
+        }
+        return null;
+    })();
+    if (!followupPayloadRaw) {
+        logProgress(5, totalSteps, 'completed (missing followup payload)', { flowId });
+        return {
+            chat: engineResult.finalChatResponse,
+            executed: true,
+            flowId: engineResult.execution.flowId
+        };
+    }
+    const loopState = buildServerToolLoopState(options.adapterContext, engineResult.execution.flowId, followupPayloadRaw);
     if (applyAutoLimit && loopState && typeof loopState.repeatCount === 'number' && loopState.repeatCount >= 3) {
+        logProgress(5, totalSteps, 'completed (auto limit hit)', { flowId });
         return {
             chat: engineResult.finalChatResponse,
             executed: true,
@@ -202,21 +346,22 @@ export async function runServerToolOrchestration(options) {
         };
     }
     if (isAdapterClientDisconnected(options.adapterContext)) {
+        logProgress(5, totalSteps, 'completed (client disconnected)', { flowId });
         return {
             chat: engineResult.finalChatResponse,
             executed: true,
             flowId: engineResult.execution.flowId
         };
     }
-    const followupEntryEndpoint = engineResult.execution.followup.entryEndpoint ||
-        options.entryEndpoint ||
-        '/v1/chat/completions';
     const metadata = {
         serverToolFollowup: true,
         stream: false,
         ...(loopState ? { serverToolLoopState: loopState } : {}),
         ...(engineResult.execution.followup.metadata ?? {})
     };
+    // Followup re-enters HubPipeline at chat-process entry with a canonical "chat-like" body.
+    // This avoids re-running per-protocol inbound parse/semantic-map for each client protocol.
+    metadata.__hubEntry = 'chat_process';
     // Enforce unified followup contract:
     // - clear any inherited routeHint
     // - do not inherit sticky target
@@ -232,7 +377,14 @@ export async function runServerToolOrchestration(options) {
     const retryEmptyFollowupOnce = isStopMessageFlow || isGeminiEmptyReplyContinue;
     const maxAttempts = retryEmptyFollowupOnce ? 2 : 1;
     const followupRequestId = buildFollowupRequestId(options.requestId, engineResult.execution.followup.requestIdSuffix);
-    const followupPayload = coerceFollowupPayloadStream(engineResult.execution.followup.payload, metadata.stream === true);
+    let followupPayload = coerceFollowupPayloadStream(followupPayloadRaw, metadata.stream === true);
+    followupPayload = applyHubFollowupPolicyShadow({
+        requestId: followupRequestId,
+        entryEndpoint: followupEntryEndpoint,
+        flowId: engineResult.execution.flowId,
+        payload: followupPayload,
+        stageRecorder: options.stageRecorder
+    });
     let followup;
     let lastError;
     // stopMessage 是一种“状态型” servertool：一旦触发，我们需要尽量避免因 followup 失败而把状态留在可继续触发的位置，
@@ -303,6 +455,7 @@ export async function runServerToolOrchestration(options) {
             // 对 stopMessage：避免把 empty followup 升级为 502，直接清理 stopMessage 状态并返回原始响应。
             // 这样客户端至少能拿到本轮输出，且 stopMessage 不会在后续请求里继续触发导致“永远 502”。
             disableStopMessageAfterFailedFollowup(options.adapterContext, stopMessageReservation);
+            logProgress(5, totalSteps, 'completed (stopMessage followup empty; cleaned state)', { flowId });
             return {
                 chat: engineResult.finalChatResponse,
                 executed: true,
@@ -323,6 +476,7 @@ export async function runServerToolOrchestration(options) {
         throw wrapped;
     }
     const decorated = decorateFinalChatWithServerToolContext(followupBody ?? engineResult.finalChatResponse, engineResult.execution);
+    logProgress(5, totalSteps, 'completed', { flowId });
     return {
         chat: decorated,
         executed: true,

package/dist/servertool/followup-shadow.d.ts

@@ -0,0 +1,16 @@
+import type { StageRecorder } from '../conversion/hub/format-adapters/index.js';
+import type { JsonObject } from '../conversion/hub/types/json.js';
+export type HubFollowupMode = 'off' | 'shadow' | 'enforce';
+export interface HubFollowupConfig {
+    mode: HubFollowupMode;
+    sampleRate?: number;
+}
+export declare function resolveHubFollowupConfigFromEnv(): HubFollowupConfig;
+export declare function applyHubFollowupPolicyShadow(args: {
+    config?: HubFollowupConfig;
+    requestId?: string;
+    entryEndpoint?: string;
+    flowId?: string;
+    payload: JsonObject;
+    stageRecorder?: StageRecorder;
+}): JsonObject;

package/dist/servertool/followup-shadow.js

@@ -0,0 +1,145 @@
+import { isJsonObject, jsonClone } from '../conversion/hub/types/json.js';
+function clampSampleRate(value) {
+    const num = typeof value === 'number' && Number.isFinite(value) ? value : 1;
+    if (num <= 0)
+        return 0;
+    if (num >= 1)
+        return 1;
+    return num;
+}
+function fnv1a32(input) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i);
+        hash = (hash * 0x01000193) >>> 0;
+    }
+    return hash >>> 0;
+}
+function shouldSample(config, requestId) {
+    const rate = clampSampleRate(config.sampleRate);
+    if (rate <= 0)
+        return false;
+    if (rate >= 1)
+        return true;
+    const key = typeof requestId === 'string' && requestId.trim().length ? requestId.trim() : 'no_request_id';
+    const bucket = fnv1a32(key) / 0xffffffff;
+    return bucket < rate;
+}
+function readMode(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (normalized === 'off' || normalized === '0' || normalized === 'false')
+        return 'off';
+    if (normalized === 'shadow')
+        return 'shadow';
+    if (normalized === 'enforce')
+        return 'enforce';
+    return null;
+}
+export function resolveHubFollowupConfigFromEnv() {
+    const raw = String(process.env.ROUTECODEX_HUB_FOLLOWUP_MODE || '').trim();
+    const mode = readMode(raw) ?? 'off';
+    const sampleRateRaw = String(process.env.ROUTECODEX_HUB_FOLLOWUP_SAMPLE_RATE || '').trim();
+    const sampleRate = sampleRateRaw ? Number(sampleRateRaw) : undefined;
+    return {
+        mode,
+        ...(Number.isFinite(sampleRate) ? { sampleRate } : {})
+    };
+}
+function dropKeyByPrefix(root, prefixes) {
+    for (const key of Object.keys(root)) {
+        if (prefixes.some((p) => key.startsWith(p))) {
+            try {
+                delete root[key];
+            }
+            catch {
+                root[key] = undefined;
+            }
+        }
+    }
+}
+function normalizeFollowupPayload(payload) {
+    const out = jsonClone(payload);
+    const record = out;
+    // Followup requests must be non-streaming and must not carry route hints.
+    if (record.stream !== undefined) {
+        record.stream = false;
+    }
+    if (record.routeHint !== undefined) {
+        delete record.routeHint;
+    }
+    if (record.route_hint !== undefined) {
+        delete record.route_hint;
+    }
+    // Remove internal/private carriers from the body (metadata belongs to request metadata, not body).
+    dropKeyByPrefix(record, ['__']);
+    const parameters = record.parameters;
+    if (isJsonObject(parameters)) {
+        const params = parameters;
+        if (params.stream !== undefined) {
+            delete params.stream;
+        }
+    }
+    return out;
+}
+function diffPayloads(baseline, candidate, p = '<root>') {
+    if (Object.is(baseline, candidate))
+        return [];
+    if (typeof baseline !== typeof candidate)
+        return [{ path: p, baseline, candidate }];
+    if (Array.isArray(baseline) && Array.isArray(candidate)) {
+        const max = Math.max(baseline.length, candidate.length);
+        const diffs = [];
+        for (let i = 0; i < max; i += 1) {
+            diffs.push(...diffPayloads(baseline[i], candidate[i], `${p}[${i}]`));
+        }
+        return diffs;
+    }
+    if (baseline && typeof baseline === 'object' && candidate && typeof candidate === 'object') {
+        const a = baseline;
+        const b = candidate;
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        const diffs = [];
+        for (const key of keys) {
+            const next = p === '<root>' ? key : `${p}.${key}`;
+            if (!(key in b))
+                diffs.push({ path: next, baseline: a[key], candidate: undefined });
+            else if (!(key in a))
+                diffs.push({ path: next, baseline: undefined, candidate: b[key] });
+            else
+                diffs.push(...diffPayloads(a[key], b[key], next));
+        }
+        return diffs;
+    }
+    return [{ path: p, baseline, candidate }];
+}
+export function applyHubFollowupPolicyShadow(args) {
+    const cfg = args.config ?? resolveHubFollowupConfigFromEnv();
+    if (!cfg || cfg.mode === 'off') {
+        return args.payload;
+    }
+    if (!shouldSample(cfg, args.requestId)) {
+        return args.payload;
+    }
+    const candidate = normalizeFollowupPayload(args.payload);
+    const diffs = diffPayloads(args.payload, candidate);
+    if (diffs.length > 0) {
+        const stage = `hub_followup.${cfg.mode}.payload`;
+        args.stageRecorder?.record(stage, {
+            kind: 'hub_followup_payload_shadow',
+            requestId: args.requestId,
+            entryEndpoint: args.entryEndpoint,
+            flowId: args.flowId,
+            diffCount: diffs.length,
+            diffPaths: diffs.slice(0, 50).map((d) => d.path),
+            diffHead: diffs.slice(0, 50).map((d) => ({ path: d.path, baseline: d.baseline, candidate: d.candidate })),
+            baseline: jsonClone(args.payload),
+            candidate: jsonClone(candidate)
+        });
+    }
+    if (cfg.mode === 'enforce') {
+        return candidate;
+    }
+    return args.payload;
+}

package/dist/servertool/handlers/apply-patch-guard.js

@@ -1,269 +1,5 @@
 import { registerServerToolHandler } from '../registry.js';
-import { cloneJson } from '../server-side-tools.js';
-import { validateToolCall } from '../../tools/tool-registry.js';
-import { buildEntryAwareFollowupPayload, extractCapturedChatSeed } from './followup-request-builder.js';
-const FLOW_ID = 'apply_patch_guard';
 const handler = async (ctx) => {
-    const toolCall = ctx.toolCall;
-    if (!toolCall) {
-        return null;
-    }
-    if (!ctx.options.reenterPipeline) {
-        return null;
-    }
-    const rawArgs = typeof toolCall.arguments === 'string' ? toolCall.arguments : '';
-    const validation = validateToolCall('apply_patch', rawArgs);
-    if (validation?.ok) {
-        return null;
-    }
-    const reason = typeof validation?.reason === 'string' && validation.reason.trim()
-        ? validation.reason.trim()
-        : 'unknown';
-    const snippet = rawArgs && rawArgs.trim().length
-        ? rawArgs.trim().slice(0, 200).replace(/\s+/g, ' ')
-        : '';
-    const isExecCommandShape = extractLikelyExecCommandShape(rawArgs);
-    // For obviously wrong shapes (e.g. exec_command-like payload passed into apply_patch),
-    // do NOT attempt a followup "recovery" loop. Return a plain assistant message instead.
-    if (isExecCommandShape && (reason === 'missing_changes' || reason === 'missing_payload' || reason === 'invalid_json')) {
-        const patched = injectApplyPatchHardFailureMessage(ctx.base, toolCall, {
-            reason,
-            snippet,
-            rawArgs
-        });
-        return {
-            chatResponse: patched,
-            execution: { flowId: FLOW_ID }
-        };
-    }
-    const patched = injectApplyPatchRejectedToolResult(ctx.base, toolCall, {
-        reason,
-        snippet,
-        rawArgs
-    });
-    const followupPayload = buildToolFollowupPayload(ctx.adapterContext, patched, ctx.options.entryEndpoint || ctx.adapterContext?.entryEndpoint || '/v1/chat/completions');
-    if (!followupPayload) {
-        // Fail-closed: if we cannot perform reenter, do not intercept.
-        // (This should be rare because HubPipeline always provides capturedChatRequest.)
-        return null;
-    }
-    return {
-        chatResponse: patched,
-        execution: {
-            flowId: FLOW_ID,
-            followup: {
-                requestIdSuffix: ':apply_patch_guard_followup',
-                payload: followupPayload
-            }
-        }
-    };
+    return null;
 };
 registerServerToolHandler('apply_patch', handler);
-function injectApplyPatchHardFailureMessage(base, toolCall, options) {
-    const cloned = cloneJson(base);
-    const choices = Array.isArray(cloned.choices)
-        ? cloned.choices
-        : [];
-    if (!choices.length) {
-        return cloned;
-    }
-    const first = choices[0];
-    if (!first || typeof first !== 'object' || Array.isArray(first)) {
-        return cloned;
-    }
-    const message = first.message;
-    if (!message || typeof message !== 'object' || Array.isArray(message)) {
-        return cloned;
-    }
-    // Replace tool-call response with a plain assistant message.
-    const guidance = buildApplyPatchGuidance(options.rawArgs);
-    const text = `[apply_patch rejected] reason=${options.reason}` +
-        (options.snippet ? ` args=${options.snippet}` : '') +
-        `\n\n${guidance}`;
-    message.content = text;
-    if (Object.prototype.hasOwnProperty.call(message, 'tool_calls')) {
-        delete message.tool_calls;
-    }
-    if (typeof first.finish_reason === 'string' && first.finish_reason === 'tool_calls') {
-        first.finish_reason = 'stop';
-    }
-    // Remove tool_outputs to avoid confusing clients that don't implement tool loops.
-    if (Object.prototype.hasOwnProperty.call(cloned, 'tool_outputs')) {
-        delete cloned.tool_outputs;
-    }
-    return cloned;
-}
-function injectApplyPatchRejectedToolResult(base, toolCall, options) {
-    const cloned = cloneJson(base);
-    const existingOutputs = Array.isArray(cloned.tool_outputs)
-        ? cloned.tool_outputs
-        : [];
-    const payload = {
-        ok: false,
-        tool: 'apply_patch',
-        reason: options.reason,
-        ...(options.snippet ? { argsSnippet: options.snippet } : {}),
-        guidance: buildApplyPatchGuidance(options.rawArgs)
-    };
-    cloned.tool_outputs = [
-        ...existingOutputs,
-        {
-            tool_call_id: toolCall.id,
-            name: 'apply_patch',
-            content: JSON.stringify(payload)
-        }
-    ];
-    return cloned;
-}
-function buildApplyPatchGuidance(rawArgs) {
-    const base = 'apply_patch 参数预检失败。请改用统一 diff（*** Begin Patch ... *** End Patch），' +
-        '或使用结构化 JSON：{ file, changes:[{ file, kind, target/anchor, lines/newText, ... }] }。';
-    const schemaHint = extractLikelyExecCommandShape(rawArgs);
-    if (schemaHint) {
-        return (base +
-            '\n\n' +
-            '你传入的参数看起来像 exec_command（例如包含 "command"/"cmd" 字段），但工具名是 apply_patch。\n' +
-            'apply_patch 必须提供非空的 "changes" 数组；如果你需要执行命令请改用 exec_command（注意：禁止通过 shell 写文件）。');
-    }
-    // User-requested hint (directory deletion is not supported via delete_file).
-    // Heuristic: detect delete_file with a directory-like target (trailing slash).
-    const hintTarget = extractDeleteFileTarget(rawArgs);
-    if (!hintTarget) {
-        return base;
-    }
-    return (base +
-        '\n\n' +
-        `- {"changes":[{"kind":"delete_file","target":"${hintTarget}"}]} ❌ 仍会 invalid_file（因为是目录）\n\n` +
-        '如果你真要删目录：请用 exec_command（例如 rm -rf tmp web-container-manager），或者用 apply_patch 逐个删目录下的文件（更安全、可审计）。');
-}
-function extractDeleteFileTarget(rawArgs) {
-    if (!rawArgs || typeof rawArgs !== 'string') {
-        return null;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(rawArgs);
-    }
-    catch {
-        return null;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return null;
-    }
-    const record = parsed;
-    const changes = Array.isArray(record.changes) ? record.changes : [];
-    for (const change of changes) {
-        if (!change || typeof change !== 'object' || Array.isArray(change))
-            continue;
-        const c = change;
-        const kind = typeof c.kind === 'string' ? c.kind.trim().toLowerCase() : '';
-        if (kind !== 'delete_file')
-            continue;
-        const target = typeof c.target === 'string' ? c.target.trim() : '';
-        if (!target)
-            continue;
-        if (target.endsWith('/')) {
-            return target;
-        }
-    }
-    return null;
-}
-function extractLikelyExecCommandShape(rawArgs) {
-    if (!rawArgs || typeof rawArgs !== 'string') {
-        return false;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(rawArgs);
-    }
-    catch {
-        return false;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return false;
-    }
-    const record = parsed;
-    const command = record.command;
-    const cmd = record.cmd;
-    if (typeof command === 'string' && command.trim()) {
-        return true;
-    }
-    if (typeof cmd === 'string' && cmd.trim()) {
-        return true;
-    }
-    return false;
-}
-function buildToolFollowupPayload(adapterContext, chatResponse, entryEndpoint) {
-    const captured = adapterContext && typeof adapterContext === 'object'
-        ? adapterContext.capturedChatRequest
-        : undefined;
-    const seed = extractCapturedChatSeed(captured);
-    if (!seed) {
-        return null;
-    }
-    const assistantMessage = extractAssistantMessage(chatResponse);
-    if (!assistantMessage) {
-        return null;
-    }
-    const toolMessages = buildToolMessages(chatResponse);
-    if (!toolMessages.length) {
-        return null;
-    }
-    const reconstructed = [...seed.messages, assistantMessage, ...toolMessages];
-    return buildEntryAwareFollowupPayload({
-        entryEndpoint,
-        model: seed.model,
-        messages: reconstructed,
-        ...(seed.tools ? { tools: seed.tools } : {}),
-        ...(seed.parameters ? { parameters: seed.parameters } : {})
-    });
-}
-function extractAssistantMessage(chatResponse) {
-    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;
-    return cloneJson(message);
-}
-function buildToolMessages(chatResponse) {
-    const toolOutputs = Array.isArray(chatResponse.tool_outputs)
-        ? chatResponse.tool_outputs
-        : [];
-    const messages = [];
-    for (const entry of toolOutputs) {
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
-            continue;
-        const record = entry;
-        const toolCallId = typeof record.tool_call_id === 'string' ? record.tool_call_id : undefined;
-        if (!toolCallId)
-            continue;
-        const name = typeof record.name === 'string' && record.name.trim() ? record.name.trim() : 'apply_patch';
-        const rawContent = record.content;
-        let contentText;
-        if (typeof rawContent === 'string') {
-            contentText = rawContent;
-        }
-        else {
-            try {
-                contentText = JSON.stringify(rawContent ?? {});
-            }
-            catch {
-                contentText = String(rawContent ?? '');
-            }
-        }
-        messages.push({
-            role: 'tool',
-            tool_call_id: toolCallId,
-            name,
-            content: contentText
-        });
-    }
-    return messages;
-}

package/dist/servertool/handlers/clock-auto.d.ts

@@ -0,0 +1 @@
+export {};