qlogicagent 0.2.1 → 0.3.0

package/dist/orchestration/transcript-repair.js

@@ -1,426 +0,0 @@
-const TOOL_CALL_NAME_MAX_CHARS = 64;
-const TOOL_CALL_NAME_RE = /^[A-Za-z0-9_-]+$/;
-const TOOL_CALL_TYPES = new Set(["toolCall", "toolUse", "functionCall"]);
-const TRANSIENT_ERROR_RE = /rate limit|rate.limited|overloaded|too many requests|quota exceeded|timed?\s*out|billing|insufficient.*(balance|quota|credit)|try again later/i;
-function isRawToolCallBlock(block) {
-    if (!block || typeof block !== "object") {
-        return false;
-    }
-    const type = block.type;
-    return typeof type === "string" && TOOL_CALL_TYPES.has(type);
-}
-function hasToolCallInput(block) {
-    const hasInput = "input" in block ? block.input !== undefined && block.input !== null : false;
-    const hasArguments = "arguments" in block ? block.arguments !== undefined && block.arguments !== null : false;
-    return hasInput || hasArguments;
-}
-function hasNonEmptyStringField(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function hasToolCallId(block) {
-    return hasNonEmptyStringField(block.id);
-}
-function trimNonEmptyString(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed || undefined;
-}
-function normalizeAllowedToolNames(allowedToolNames) {
-    if (!allowedToolNames) {
-        return null;
-    }
-    const normalized = new Set();
-    for (const name of allowedToolNames) {
-        if (typeof name !== "string") {
-            continue;
-        }
-        const trimmed = name.trim();
-        if (trimmed) {
-            normalized.add(trimmed.toLowerCase());
-        }
-    }
-    return normalized.size > 0 ? normalized : null;
-}
-function hasToolCallName(block, allowedToolNames) {
-    if (typeof block.name !== "string") {
-        return false;
-    }
-    const trimmed = block.name.trim();
-    if (!trimmed) {
-        return false;
-    }
-    if (trimmed.length > TOOL_CALL_NAME_MAX_CHARS || !TOOL_CALL_NAME_RE.test(trimmed)) {
-        return false;
-    }
-    if (!allowedToolNames) {
-        return true;
-    }
-    return allowedToolNames.has(trimmed.toLowerCase());
-}
-function redactSessionsSpawnAttachmentsArgs(value) {
-    if (!value || typeof value !== "object") {
-        return value;
-    }
-    const record = value;
-    const raw = record.attachments;
-    if (!Array.isArray(raw)) {
-        return value;
-    }
-    const next = raw.map((item) => {
-        if (!item || typeof item !== "object") {
-            return item;
-        }
-        const attachment = item;
-        if (!Object.hasOwn(attachment, "content")) {
-            return item;
-        }
-        const { content: _content, ...rest } = attachment;
-        return { ...rest, content: "__OPENCLAW_REDACTED__" };
-    });
-    return { ...record, attachments: next };
-}
-function sanitizeToolCallBlock(block) {
-    const rawName = typeof block.name === "string" ? block.name : undefined;
-    const trimmedName = rawName?.trim();
-    const hasTrimmedName = typeof trimmedName === "string" && trimmedName.length > 0;
-    const normalizedName = hasTrimmedName ? trimmedName : undefined;
-    const nameChanged = hasTrimmedName && rawName !== trimmedName;
-    const isDelegatedSessionSpawnToolCall = normalizedName?.toLowerCase() === "sessions_spawn";
-    if (!isDelegatedSessionSpawnToolCall) {
-        if (!nameChanged) {
-            return block;
-        }
-        return { ...block, name: normalizedName };
-    }
-    const nextArgs = redactSessionsSpawnAttachmentsArgs(block.arguments);
-    const nextInput = redactSessionsSpawnAttachmentsArgs(block.input);
-    if (nextArgs === block.arguments && nextInput === block.input && !nameChanged) {
-        return block;
-    }
-    const next = { ...block };
-    if (nameChanged && normalizedName) {
-        next.name = normalizedName;
-    }
-    if (nextArgs !== block.arguments || Object.hasOwn(block, "arguments")) {
-        next.arguments = nextArgs;
-    }
-    if (nextInput !== block.input || Object.hasOwn(block, "input")) {
-        next.input = nextInput;
-    }
-    return next;
-}
-function normalizeToolResultName(message, fallbackName) {
-    const rawToolName = message.toolName;
-    const normalizedToolName = trimNonEmptyString(rawToolName);
-    if (normalizedToolName) {
-        if (rawToolName === normalizedToolName) {
-            return message;
-        }
-        return { ...message, toolName: normalizedToolName };
-    }
-    const normalizedFallback = trimNonEmptyString(fallbackName);
-    if (normalizedFallback) {
-        return { ...message, toolName: normalizedFallback };
-    }
-    if (typeof rawToolName === "string") {
-        return { ...message, toolName: "unknown" };
-    }
-    return message;
-}
-function extractToolCallsFromAssistantLike(message) {
-    const content = message.content;
-    if (!Array.isArray(content)) {
-        return [];
-    }
-    const toolCalls = [];
-    for (const block of content) {
-        if (!block || typeof block !== "object") {
-            continue;
-        }
-        const record = block;
-        if (typeof record.id !== "string" || !record.id) {
-            continue;
-        }
-        if (typeof record.type === "string" && TOOL_CALL_TYPES.has(record.type)) {
-            toolCalls.push({
-                id: record.id,
-                name: typeof record.name === "string" ? record.name : undefined,
-            });
-        }
-    }
-    return toolCalls;
-}
-function extractToolResultIdLike(message) {
-    if (typeof message.toolCallId === "string" && message.toolCallId) {
-        return message.toolCallId;
-    }
-    if (typeof message.toolUseId === "string" && message.toolUseId) {
-        return message.toolUseId;
-    }
-    return null;
-}
-function defaultMissingToolResult(params) {
-    return {
-        role: "toolResult",
-        toolCallId: params.toolCallId,
-        toolName: params.toolName ?? "unknown",
-        content: [
-            {
-                type: "text",
-                text: "[qlogicagent] missing tool result in session history; inserted synthetic error result for transcript repair.",
-            },
-        ],
-        isError: true,
-        timestamp: 0,
-    };
-}
-export function stripToolResultDetails(messages) {
-    let touched = false;
-    const out = [];
-    for (const message of messages) {
-        if (!message || typeof message !== "object" || message.role !== "toolResult") {
-            out.push(message);
-            continue;
-        }
-        if (!("details" in message)) {
-            out.push(message);
-            continue;
-        }
-        const sanitized = { ...message };
-        delete sanitized.details;
-        touched = true;
-        out.push(sanitized);
-    }
-    return touched ? out : [...messages];
-}
-export function repairToolCallInputs(messages, options) {
-    let droppedToolCalls = 0;
-    let droppedAssistantMessages = 0;
-    let changed = false;
-    const out = [];
-    const allowedToolNames = normalizeAllowedToolNames(options?.allowedToolNames);
-    for (const message of messages) {
-        if (!message || typeof message !== "object") {
-            out.push(message);
-            continue;
-        }
-        if (message.role !== "assistant" || !Array.isArray(message.content)) {
-            out.push(message);
-            continue;
-        }
-        const nextContent = [];
-        let droppedInMessage = 0;
-        let messageChanged = false;
-        for (const block of message.content) {
-            if (isRawToolCallBlock(block) &&
-                (!hasToolCallInput(block) ||
-                    !hasToolCallId(block) ||
-                    !hasToolCallName(block, allowedToolNames))) {
-                droppedToolCalls += 1;
-                droppedInMessage += 1;
-                changed = true;
-                messageChanged = true;
-                continue;
-            }
-            if (isRawToolCallBlock(block)) {
-                const blockName = typeof block.name === "string" ? block.name.trim() : undefined;
-                if (blockName?.toLowerCase() === "sessions_spawn") {
-                    const sanitized = sanitizeToolCallBlock(block);
-                    if (sanitized !== block) {
-                        changed = true;
-                        messageChanged = true;
-                    }
-                    nextContent.push(sanitized);
-                    continue;
-                }
-                if (typeof block.name === "string") {
-                    const trimmedName = block.name.trim();
-                    if (trimmedName && trimmedName !== block.name) {
-                        nextContent.push({ ...block, name: trimmedName });
-                        changed = true;
-                        messageChanged = true;
-                        continue;
-                    }
-                }
-            }
-            nextContent.push(block);
-        }
-        if (droppedInMessage > 0) {
-            if (nextContent.length === 0) {
-                droppedAssistantMessages += 1;
-                changed = true;
-                continue;
-            }
-            out.push({ ...message, content: nextContent });
-            continue;
-        }
-        if (messageChanged) {
-            out.push({ ...message, content: nextContent });
-            continue;
-        }
-        out.push(message);
-    }
-    return {
-        messages: changed ? out : [...messages],
-        droppedToolCalls,
-        droppedAssistantMessages,
-    };
-}
-export function sanitizeToolCallInputs(messages, options) {
-    return repairToolCallInputs(messages, options).messages;
-}
-export function repairToolUseResultPairing(messages, options) {
-    const out = [];
-    const added = [];
-    const seenToolResultIds = new Set();
-    let droppedDuplicateCount = 0;
-    let droppedOrphanCount = 0;
-    let moved = false;
-    let changed = false;
-    const createMissingToolResult = options?.createMissingToolResult ?? (defaultMissingToolResult);
-    const pushToolResult = (message) => {
-        const id = extractToolResultIdLike(message);
-        if (id && seenToolResultIds.has(id)) {
-            droppedDuplicateCount += 1;
-            changed = true;
-            return;
-        }
-        if (id) {
-            seenToolResultIds.add(id);
-        }
-        out.push(message);
-    };
-    for (let i = 0; i < messages.length; i += 1) {
-        const message = messages[i];
-        if (!message || typeof message !== "object") {
-            out.push(message);
-            continue;
-        }
-        if (message.role !== "assistant") {
-            if (message.role !== "toolResult") {
-                out.push(message);
-            }
-            else {
-                droppedOrphanCount += 1;
-                changed = true;
-            }
-            continue;
-        }
-        const stopReason = message.stopReason;
-        if (stopReason === "error" || stopReason === "aborted") {
-            out.push(message);
-            continue;
-        }
-        const toolCalls = extractToolCallsFromAssistantLike(message);
-        if (toolCalls.length === 0) {
-            out.push(message);
-            continue;
-        }
-        const toolCallIds = new Set(toolCalls.map((toolCall) => toolCall.id));
-        const toolCallNamesById = new Map(toolCalls.map((toolCall) => [toolCall.id, toolCall.name]));
-        const spanResultsById = new Map();
-        const remainder = [];
-        let j = i + 1;
-        for (; j < messages.length; j += 1) {
-            const next = messages[j];
-            if (!next || typeof next !== "object") {
-                remainder.push(next);
-                continue;
-            }
-            if (next.role === "assistant") {
-                break;
-            }
-            if (next.role === "toolResult") {
-                const id = extractToolResultIdLike(next);
-                if (id && toolCallIds.has(id)) {
-                    if (seenToolResultIds.has(id)) {
-                        droppedDuplicateCount += 1;
-                        changed = true;
-                        continue;
-                    }
-                    const normalizedToolResult = normalizeToolResultName(next, toolCallNamesById.get(id));
-                    if (normalizedToolResult !== next) {
-                        changed = true;
-                    }
-                    if (!spanResultsById.has(id)) {
-                        spanResultsById.set(id, normalizedToolResult);
-                    }
-                    continue;
-                }
-            }
-            if (next.role !== "toolResult") {
-                remainder.push(next);
-            }
-            else {
-                droppedOrphanCount += 1;
-                changed = true;
-            }
-        }
-        out.push(message);
-        if (spanResultsById.size > 0 && remainder.length > 0) {
-            moved = true;
-            changed = true;
-        }
-        for (const call of toolCalls) {
-            const existing = spanResultsById.get(call.id);
-            if (existing) {
-                pushToolResult(existing);
-            }
-            else {
-                const missing = createMissingToolResult({
-                    toolCallId: call.id,
-                    toolName: call.name,
-                });
-                added.push(missing);
-                changed = true;
-                pushToolResult(missing);
-            }
-        }
-        for (const rem of remainder) {
-            out.push(rem);
-        }
-        i = j - 1;
-    }
-    const changedOrMoved = changed || moved;
-    return {
-        messages: changedOrMoved ? out : [...messages],
-        added,
-        droppedDuplicateCount,
-        droppedOrphanCount,
-        moved: changedOrMoved,
-    };
-}
-export function sanitizeToolUseResultPairing(messages, options) {
-    return repairToolUseResultPairing(messages, options).messages;
-}
-export function stripTransientErrorMessages(messages) {
-    let changed = false;
-    const out = [];
-    for (const message of messages) {
-        if (!message || typeof message !== "object") {
-            out.push(message);
-            continue;
-        }
-        if (message.role !== "assistant" || message.stopReason !== "error") {
-            out.push(message);
-            continue;
-        }
-        const content = message.content;
-        const text = typeof content === "string"
-            ? content
-            : Array.isArray(content)
-                ? content
-                    .filter((block) => block.type === "text")
-                    .map((block) => block.text ?? "")
-                    .join(" ")
-                : "";
-        if (!TRANSIENT_ERROR_RE.test(text)) {
-            out.push(message);
-            continue;
-        }
-        changed = true;
-    }
-    return changed ? out : [...messages];
-}

package/dist/orchestration/turn-loop-guard.js

@@ -1,92 +0,0 @@
-/**
- * Turn Loop Guard — Abort signal + token budget warning for preventive termination.
- *
- * Aligned with Claude Code's multi-condition termination:
- * 1. AbortSignal from user cancellation
- * 2. Token budget pre-check (don't send API call if over budget)
- * 3. max_output_tokens escalation on truncation
- * 4. Prompt-too-long reactive compact trigger
- */
-/** Initial guard state. */
-export function createTurnLoopGuardState(config) {
-    return {
-        promptTokens: 0,
-        hasAttemptedReactiveCompact: false,
-        currentMaxOutputTokens: config.maxOutputTokens,
-        consecutiveTruncations: 0,
-        aborted: config.abortSignal?.aborted ?? false,
-    };
-}
-/**
- * Calculate token warning state before making an API call.
- * If level is "blocking", do NOT send the API call.
- */
-export function calculateTokenWarningState(state, config) {
-    if (state.aborted) {
-        return { level: "blocking", usagePercent: 100, reason: "budget_exhausted" };
-    }
-    const effectiveLimit = config.contextWindowTokens - config.responseBufferTokens - state.currentMaxOutputTokens;
-    const usagePercent = effectiveLimit > 0 ? (state.promptTokens / effectiveLimit) * 100 : 100;
-    if (state.promptTokens >= effectiveLimit) {
-        if (state.hasAttemptedReactiveCompact || !config.reactiveCompactEnabled) {
-            return { level: "blocking", usagePercent, reason: "prompt_too_long" };
-        }
-        return { level: "blocking", usagePercent, reason: "prompt_too_long" };
-    }
-    // Warning at 85%
-    if (usagePercent >= 85) {
-        return { level: "warning", usagePercent, remainingTokens: effectiveLimit - state.promptTokens };
-    }
-    return { level: "ok" };
-}
-export function resolveApiErrorRecovery(error, state, config) {
-    const msg = error.message?.toLowerCase() ?? "";
-    const status = error.status ?? 0;
-    // Prompt too long (413 or specific error message)
-    if (status === 413 || msg.includes("prompt_too_long") || msg.includes("context_length_exceeded")) {
-        if (!state.hasAttemptedReactiveCompact && config.reactiveCompactEnabled) {
-            return { action: "reactive_compact" };
-        }
-        return { action: "abort", reason: "prompt_too_long_unrecoverable" };
-    }
-    // 5xx transient errors
-    if (status >= 500 && status < 600) {
-        return { action: "retry", reason: `server_error_${status}` };
-    }
-    // Rate limit
-    if (status === 429) {
-        return { action: "retry", reason: "rate_limited" };
-    }
-    return { action: "abort", reason: msg || "unknown_error" };
-}
-/**
- * Handle finish_reason === "max_tokens" — escalate max_output_tokens.
- *
- * CC pattern: double the output token budget up to model max.
- */
-export function resolveOutputTokenEscalation(state, config, modelMaxOutput) {
-    if (!config.outputEscalationEnabled) {
-        return { shouldEscalate: false, newMax: state.currentMaxOutputTokens };
-    }
-    // Don't escalate more than 3 times
-    if (state.consecutiveTruncations >= 3) {
-        return { shouldEscalate: false, newMax: state.currentMaxOutputTokens };
-    }
-    const newMax = Math.min(state.currentMaxOutputTokens * 2, modelMaxOutput);
-    if (newMax <= state.currentMaxOutputTokens) {
-        return { shouldEscalate: false, newMax: state.currentMaxOutputTokens };
-    }
-    return { shouldEscalate: true, newMax };
-}
-/**
- * Check if the turn should be aborted (user cancellation).
- */
-export function shouldAbortTurn(state, config) {
-    if (state.aborted)
-        return true;
-    if (config.abortSignal?.aborted) {
-        state.aborted = true;
-        return true;
-    }
-    return false;
-}

package/dist/orchestration/web-browser-policy.js

@@ -1,39 +0,0 @@
-function pushReason(reasons, enabled, reason) {
-    if (enabled) {
-        reasons.add(reason);
-    }
-}
-export function resolveWebBrowserPolicy(params) {
-    const capability = params.capability;
-    const reasons = new Set(capability?.escalationReasons ?? []);
-    pushReason(reasons, params.needsInteractiveSession === true, "requires-interaction");
-    pushReason(reasons, params.needsLoginState === true, "requires-login-state");
-    pushReason(reasons, params.needsPersistentSession === true, "requires-persistent-session");
-    pushReason(reasons, params.needsStateChangingAction === true, "requires-state-changing-action");
-    const shouldEscalateToBrowser = capability?.capabilityFamily === "browser-execution"
-        || capability?.taskMode === "interactive-browser"
-        || reasons.size > 0;
-    if (!shouldEscalateToBrowser) {
-        return {
-            selectedCapabilityFamily: "web-intelligence",
-            selectedTaskMode: capability?.taskMode,
-            shouldEscalateToBrowser: false,
-            escalationReasons: [],
-        };
-    }
-    if (params.browserAvailable !== false) {
-        return {
-            selectedCapabilityFamily: "browser-execution",
-            selectedTaskMode: "interactive-browser",
-            shouldEscalateToBrowser: true,
-            escalationReasons: [...reasons],
-        };
-    }
-    return {
-        selectedCapabilityFamily: capability?.capabilityFamily ?? "web-intelligence",
-        selectedTaskMode: capability?.taskMode,
-        shouldEscalateToBrowser: false,
-        degradationTarget: capability?.degradationTarget,
-        escalationReasons: [...reasons],
-    };
-}