qlogicagent 0.2.1 → 0.3.0

package/dist/orchestration/conversation-repair.js

@@ -1,429 +0,0 @@
-const DEFAULT_FORCED_STOP_REASONS = ["stop", "aborted", "timeout", "cancelled", "interrupted", "error"];
-const FORCED_STOP_ASSISTANT_METADATA_KEYS = [
-    "tool_calls",
-    "toolCalls",
-    "function_call",
-    "functionCall",
-    "raw_tool_calls",
-    "rawToolCalls",
-];
-function normalizeUserMessageContent(content) {
-    if (content == null) {
-        return [];
-    }
-    if (typeof content === "string") {
-        return content.length > 0 ? [{ type: "text", text: content }] : [];
-    }
-    if (Array.isArray(content)) {
-        return content;
-    }
-    return [{ type: "text", text: String(content) }];
-}
-function mergeConsecutiveUserMessages(left, right) {
-    return {
-        ...left,
-        content: [
-            ...normalizeUserMessageContent(left.content),
-            ...normalizeUserMessageContent(right.content),
-        ],
-    };
-}
-function isValidOpenAiChatToolCall(call) {
-    if (!call || typeof call !== "object") {
-        return false;
-    }
-    if (call.function && typeof call.function === "object") {
-        const functionName = call.function.name;
-        if (typeof functionName === "string" && functionName.length > 0) {
-            return true;
-        }
-    }
-    return typeof call.name === "string" && call.name.length > 0;
-}
-function normalizeForcedStopReasons(forcedStopReasons) {
-    return new Set((forcedStopReasons ?? DEFAULT_FORCED_STOP_REASONS).map((reason) => reason.trim().toLowerCase()));
-}
-function shouldStripForcedStopToolMetadata(stopReason, forcedStopReasons) {
-    if (!stopReason) {
-        return false;
-    }
-    return normalizeForcedStopReasons(forcedStopReasons).has(stopReason.trim().toLowerCase());
-}
-function splitOpenAiFunctionCallPairing(id) {
-    const separator = id.indexOf("|");
-    if (separator <= 0 || separator >= id.length - 1) {
-        return { callId: id };
-    }
-    return {
-        callId: id.slice(0, separator),
-        itemId: id.slice(separator + 1),
-    };
-}
-function parseOpenAiReasoningSignature(value) {
-    if (!value) {
-        return null;
-    }
-    let candidate = null;
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
-            return null;
-        }
-        try {
-            candidate = JSON.parse(trimmed);
-        }
-        catch {
-            return null;
-        }
-    }
-    else if (typeof value === "object") {
-        candidate = value;
-    }
-    if (!candidate) {
-        return null;
-    }
-    const id = typeof candidate.id === "string" ? candidate.id : "";
-    const type = typeof candidate.type === "string" ? candidate.type : "";
-    if (!id.startsWith("rs_")) {
-        return null;
-    }
-    if (type === "reasoning" || type.startsWith("reasoning.")) {
-        return { id, type };
-    }
-    return null;
-}
-function hasFollowingNonThinkingBlock(content, index) {
-    for (let nextIndex = index + 1; nextIndex < content.length; nextIndex += 1) {
-        const block = content[nextIndex];
-        if (!block || typeof block !== "object") {
-            return true;
-        }
-        if (block.type !== "thinking") {
-            return true;
-        }
-    }
-    return false;
-}
-export function sanitizeOpenAiChatMessages(messages) {
-    if (!Array.isArray(messages) || messages.length === 0) {
-        return [...messages];
-    }
-    const normalizedMessages = messages.map((message) => {
-        if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
-            const validToolCalls = message.tool_calls.filter((call) => isValidOpenAiChatToolCall(call));
-            return {
-                ...message,
-                ...(validToolCalls.length > 0 ? { tool_calls: validToolCalls } : { tool_calls: undefined }),
-            };
-        }
-        return { ...message };
-    });
-    const validToolCallIds = new Set();
-    for (const message of normalizedMessages) {
-        if (message.role !== "assistant" || !Array.isArray(message.tool_calls)) {
-            continue;
-        }
-        for (const toolCall of message.tool_calls) {
-            if (typeof toolCall.id === "string" && toolCall.id) {
-                validToolCallIds.add(toolCall.id);
-            }
-        }
-    }
-    const withoutOrphanToolMessages = normalizedMessages.filter((message) => {
-        if (message.role !== "tool") {
-            return true;
-        }
-        return Boolean(message.tool_call_id && validToolCallIds.has(message.tool_call_id));
-    });
-    const survivingToolIds = new Set();
-    for (const message of withoutOrphanToolMessages) {
-        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
-            survivingToolIds.add(message.tool_call_id);
-        }
-    }
-    const cleanedMessages = [];
-    for (const message of withoutOrphanToolMessages) {
-        if (message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
-            const matchedToolCalls = message.tool_calls.filter((toolCall) => typeof toolCall.id === "string" && survivingToolIds.has(toolCall.id));
-            if (matchedToolCalls.length === 0) {
-                const { tool_calls: _droppedToolCalls, ...rest } = message;
-                if (rest.content != null && rest.content !== "") {
-                    cleanedMessages.push(rest);
-                }
-                continue;
-            }
-            if (matchedToolCalls.length < message.tool_calls.length) {
-                cleanedMessages.push({ ...message, tool_calls: matchedToolCalls });
-                continue;
-            }
-        }
-        cleanedMessages.push(message);
-    }
-    const mergedMessages = [];
-    for (const message of cleanedMessages) {
-        const previous = mergedMessages.length > 0 ? mergedMessages[mergedMessages.length - 1] : undefined;
-        if (message.role === "user" && previous?.role === "user") {
-            mergedMessages[mergedMessages.length - 1] = mergeConsecutiveUserMessages(previous, message);
-            continue;
-        }
-        mergedMessages.push(message);
-    }
-    return mergedMessages;
-}
-export function ensureAssistantReasoningContent(messages, defaultValue = "") {
-    return messages.map((message) => {
-        if (message.role === "assistant" && !Object.hasOwn(message, "reasoning_content")) {
-            return { ...message, reasoning_content: defaultValue };
-        }
-        return { ...message };
-    });
-}
-export function stripForcedStopAssistantToolMetadata(messages, options) {
-    if (!shouldStripForcedStopToolMetadata(options?.stopReason, options?.forcedStopReasons)) {
-        return [...messages];
-    }
-    return messages.map((message) => {
-        if (message.role !== "assistant") {
-            return { ...message };
-        }
-        const nextMessage = { ...message };
-        for (const key of FORCED_STOP_ASSISTANT_METADATA_KEYS) {
-            delete nextMessage[key];
-        }
-        return nextMessage;
-    });
-}
-export function injectDanglingToolCallPlaceholders(messages, options) {
-    const placeholderContent = options?.placeholderToolResult ?? JSON.stringify({ ok: false, error: "Tool loop interrupted before the tool result was replayed." });
-    const matchedToolResultIds = new Set();
-    for (const message of messages) {
-        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
-            matchedToolResultIds.add(message.tool_call_id);
-        }
-    }
-    const repairedMessages = [];
-    for (const message of messages) {
-        repairedMessages.push({ ...message });
-        if (message.role !== "assistant" || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
-            continue;
-        }
-        for (const toolCall of message.tool_calls) {
-            if (typeof toolCall.id !== "string" || !toolCall.id || matchedToolResultIds.has(toolCall.id)) {
-                continue;
-            }
-            matchedToolResultIds.add(toolCall.id);
-            repairedMessages.push({
-                role: "tool",
-                tool_call_id: toolCall.id,
-                content: placeholderContent,
-            });
-        }
-    }
-    return repairedMessages;
-}
-export function repairOpenAiChatConversation(messages, options) {
-    const sanitizedMessages = sanitizeOpenAiChatMessages(messages);
-    const strippedMessages = stripForcedStopAssistantToolMetadata(sanitizedMessages, options);
-    return injectDanglingToolCallPlaceholders(strippedMessages, options);
-}
-export function downgradeOpenAiFunctionCallReasoningPairs(messages) {
-    let changed = false;
-    const rewrittenMessages = [];
-    let pendingRewrittenIds = null;
-    for (const message of messages) {
-        if (!message || typeof message !== "object") {
-            pendingRewrittenIds = null;
-            rewrittenMessages.push(message);
-            continue;
-        }
-        if (message.role === "assistant") {
-            if (!Array.isArray(message.content)) {
-                pendingRewrittenIds = null;
-                rewrittenMessages.push(message);
-                continue;
-            }
-            const localRewrittenIds = new Map();
-            let seenReplayableReasoning = false;
-            let assistantChanged = false;
-            const nextContent = message.content.map((block) => {
-                if (!block || typeof block !== "object") {
-                    return block;
-                }
-                const maybeThinking = block;
-                if (maybeThinking.type === "thinking" && parseOpenAiReasoningSignature(maybeThinking.thinkingSignature)) {
-                    seenReplayableReasoning = true;
-                    return block;
-                }
-                const maybeToolCall = block;
-                if (!["toolCall", "toolUse", "functionCall"].includes(String(maybeToolCall.type)) || typeof maybeToolCall.id !== "string") {
-                    return block;
-                }
-                const pairing = splitOpenAiFunctionCallPairing(maybeToolCall.id);
-                if (seenReplayableReasoning || !pairing.itemId || !pairing.itemId.startsWith("fc_")) {
-                    return block;
-                }
-                assistantChanged = true;
-                localRewrittenIds.set(maybeToolCall.id, pairing.callId);
-                return {
-                    ...block,
-                    id: pairing.callId,
-                };
-            });
-            pendingRewrittenIds = localRewrittenIds.size > 0 ? localRewrittenIds : null;
-            if (!assistantChanged) {
-                rewrittenMessages.push(message);
-                continue;
-            }
-            changed = true;
-            rewrittenMessages.push({ ...message, content: nextContent });
-            continue;
-        }
-        if (message.role === "toolResult" && pendingRewrittenIds && pendingRewrittenIds.size > 0) {
-            const updates = {};
-            let toolResultChanged = false;
-            if (typeof message.toolCallId === "string") {
-                const nextToolCallId = pendingRewrittenIds.get(message.toolCallId);
-                if (nextToolCallId && nextToolCallId !== message.toolCallId) {
-                    updates.toolCallId = nextToolCallId;
-                    toolResultChanged = true;
-                }
-            }
-            if (typeof message.toolUseId === "string") {
-                const nextToolUseId = pendingRewrittenIds.get(message.toolUseId);
-                if (nextToolUseId && nextToolUseId !== message.toolUseId) {
-                    updates.toolUseId = nextToolUseId;
-                    toolResultChanged = true;
-                }
-            }
-            if (!toolResultChanged) {
-                rewrittenMessages.push(message);
-                continue;
-            }
-            changed = true;
-            rewrittenMessages.push({ ...message, ...updates });
-            continue;
-        }
-        pendingRewrittenIds = null;
-        rewrittenMessages.push(message);
-    }
-    return changed ? rewrittenMessages : [...messages];
-}
-export function downgradeOpenAiReasoningBlocks(messages) {
-    const out = [];
-    for (const message of messages) {
-        if (!message || typeof message !== "object") {
-            out.push(message);
-            continue;
-        }
-        if (message.role !== "assistant") {
-            out.push(message);
-            continue;
-        }
-        if (!Array.isArray(message.content)) {
-            out.push(message);
-            continue;
-        }
-        let changed = false;
-        const nextContent = [];
-        for (let index = 0; index < message.content.length; index += 1) {
-            const block = message.content[index];
-            if (!block || typeof block !== "object") {
-                nextContent.push(block);
-                continue;
-            }
-            const record = block;
-            if (record.type !== "thinking") {
-                nextContent.push(block);
-                continue;
-            }
-            const signature = parseOpenAiReasoningSignature(record.thinkingSignature);
-            if (!signature) {
-                nextContent.push(block);
-                continue;
-            }
-            if (hasFollowingNonThinkingBlock(message.content, index)) {
-                nextContent.push(block);
-                continue;
-            }
-            changed = true;
-        }
-        if (!changed) {
-            out.push(message);
-            continue;
-        }
-        if (nextContent.length === 0) {
-            continue;
-        }
-        out.push({ ...message, content: nextContent });
-    }
-    return out;
-}
-export function repairOpenAiResponsesItems(items, options) {
-    const placeholderOutput = options?.placeholderFunctionCallOutput ?? JSON.stringify({ ok: false, error: "Tool loop interrupted before function_call_output was provided." });
-    const stripForced = shouldStripForcedStopToolMetadata(options?.stopReason, options?.forcedStopReasons);
-    const rewrittenItems = [];
-    for (let index = 0; index < items.length; index += 1) {
-        const item = items[index];
-        if (!item || typeof item !== "object") {
-            rewrittenItems.push(item);
-            continue;
-        }
-        if (item.type === "reasoning" && typeof item.id === "string" && item.id.startsWith("rs_")) {
-            const hasFollowingNonReasoning = items.slice(index + 1).some((next) => next && typeof next === "object" && next.type !== "reasoning");
-            if (!hasFollowingNonReasoning) {
-                continue;
-            }
-        }
-        if (item.type !== "function_call") {
-            rewrittenItems.push({ ...item });
-            continue;
-        }
-        const nextItem = { ...item };
-        if (typeof nextItem.id === "string") {
-            const pairing = splitOpenAiFunctionCallPairing(nextItem.id);
-            if (pairing.itemId?.startsWith("fc_")) {
-                nextItem.id = pairing.callId;
-            }
-        }
-        rewrittenItems.push(nextItem);
-    }
-    const validFunctionCallIds = new Set();
-    const functionCallByCallId = new Map();
-    for (const item of rewrittenItems) {
-        if (item.type !== "function_call") {
-            continue;
-        }
-        const callId = typeof item.call_id === "string" && item.call_id ? item.call_id : typeof item.id === "string" ? item.id : undefined;
-        if (!callId) {
-            continue;
-        }
-        validFunctionCallIds.add(callId);
-        functionCallByCallId.set(callId, item);
-    }
-    const pairedOutputs = new Set();
-    const repairedItems = [];
-    for (const item of rewrittenItems) {
-        if (stripForced && item.type === "function_call") {
-            continue;
-        }
-        if (item.type === "function_call_output") {
-            const callId = typeof item.call_id === "string" ? item.call_id : "";
-            if (!callId || !validFunctionCallIds.has(callId)) {
-                continue;
-            }
-            pairedOutputs.add(callId);
-        }
-        repairedItems.push(item);
-    }
-    for (const [callId] of functionCallByCallId) {
-        if (pairedOutputs.has(callId) || stripForced) {
-            continue;
-        }
-        repairedItems.push({
-            type: "function_call_output",
-            call_id: callId,
-            output: placeholderOutput,
-        });
-    }
-    return repairedItems;
-}

package/dist/orchestration/curator-scheduler.js

@@ -1,135 +0,0 @@
-/**
- * Curator scheduler — pure strategy for autonomous skill library
- * maintenance. Decides WHEN to run the curator review cycle and
- * computes automatic lifecycle transitions (active → stale → archived).
- *
- * No I/O — all functions are pure; the caller supplies timestamps and
- * skill records, and receives transition instructions back.
- */
-export const DEFAULT_CURATOR_SCHEDULE_POLICY = {
-    minIdleSeconds: 7200,
-    intervalSeconds: 604_800,
-    staleAfterDays: 30,
-    archiveAfterDays: 90,
-    maxReviewBatchSize: 50,
-};
-export const INITIAL_CURATOR_STATE = {
-    lastRunAt: null,
-    lastRunDurationSeconds: 0,
-    lastRunSummary: "",
-    paused: false,
-    runCount: 0,
-};
-/**
- * Determine whether the curator should run now.
- *
- * All gates must pass:
- * 1. Feature enabled
- * 2. Not paused
- * 3. Session idle ≥ minIdleSeconds
- * 4. Time since last run ≥ intervalSeconds
- */
-export function shouldRunCurator(input) {
-    const policy = { ...DEFAULT_CURATOR_SCHEDULE_POLICY, ...input.policy };
-    if (!input.enabled) {
-        return { shouldRun: false, reason: "curator disabled" };
-    }
-    if (input.state.paused) {
-        return { shouldRun: false, reason: "curator paused by user" };
-    }
-    if (input.idleSeconds < policy.minIdleSeconds) {
-        return {
-            shouldRun: false,
-            reason: `session not idle long enough (${input.idleSeconds}s < ${policy.minIdleSeconds}s)`,
-        };
-    }
-    if (input.state.lastRunAt) {
-        const elapsed = (new Date(input.now).getTime() - new Date(input.state.lastRunAt).getTime()) / 1000;
-        if (elapsed < policy.intervalSeconds) {
-            return {
-                shouldRun: false,
-                reason: `last run too recent (${Math.round(elapsed)}s < ${policy.intervalSeconds}s)`,
-            };
-        }
-    }
-    return { shouldRun: true, reason: "all gates passed" };
-}
-/**
- * Compute automatic lifecycle transitions for agent-created skills.
- *
- * Pure function — no I/O, no mutations. The caller applies the
- * returned transitions to its skill storage.
- *
- * Rules:
- * - Pinned skills are never transitioned.
- * - Non-agent-created skills are skipped.
- * - active → stale: no activity for staleAfterDays.
- * - stale → archived: no activity for archiveAfterDays.
- * - stale/archived → active: if useCount increased (reactivation).
- */
-export function computeLifecycleTransitions(skills, now, policy) {
-    const resolved = { ...DEFAULT_CURATOR_SCHEDULE_POLICY, ...policy };
-    const nowMs = new Date(now).getTime();
-    const transitions = [];
-    let checked = 0;
-    for (const skill of skills) {
-        if (!skill.agentCreated)
-            continue;
-        checked++;
-        if (skill.pinned)
-            continue;
-        const lastMs = skill.lastActivityAt
-            ? new Date(skill.lastActivityAt).getTime()
-            : new Date(skill.createdAt).getTime();
-        const inactiveDays = (nowMs - lastMs) / (1000 * 60 * 60 * 24);
-        if (skill.state === "active" && inactiveDays >= resolved.staleAfterDays) {
-            transitions.push({
-                skillName: skill.name,
-                from: "active",
-                to: "stale",
-                reason: `inactive for ${Math.floor(inactiveDays)} days (threshold: ${resolved.staleAfterDays})`,
-            });
-        }
-        else if (skill.state === "stale" && inactiveDays >= resolved.archiveAfterDays) {
-            transitions.push({
-                skillName: skill.name,
-                from: "stale",
-                to: "archived",
-                reason: `inactive for ${Math.floor(inactiveDays)} days (threshold: ${resolved.archiveAfterDays})`,
-            });
-        }
-        // Reactivation: stale/archived skill with recent activity
-        if ((skill.state === "stale" || skill.state === "archived")
-            && skill.useCount > 0
-            && inactiveDays < resolved.staleAfterDays) {
-            transitions.push({
-                skillName: skill.name,
-                from: skill.state,
-                to: "active",
-                reason: "recent activity detected — reactivated",
-            });
-        }
-    }
-    return {
-        checked,
-        transitions,
-        markedStale: transitions.filter((t) => t.to === "stale").length,
-        archived: transitions.filter((t) => t.to === "archived").length,
-        reactivated: transitions.filter((t) => t.to === "active").length,
-    };
-}
-// ── Review candidate selection ─────────────────────────────────────
-/**
- * Select skills that should be reviewed by the LLM curator.
- *
- * Only non-pinned, agent-created skills in active or stale state
- * are eligible for review. Returns at most maxReviewBatchSize names.
- */
-export function selectReviewCandidates(skills, policy) {
-    const resolved = { ...DEFAULT_CURATOR_SCHEDULE_POLICY, ...policy };
-    return skills
-        .filter((s) => s.agentCreated && !s.pinned && (s.state === "active" || s.state === "stale"))
-        .sort((a, b) => a.useCount - b.useCount) // least-used first → most likely consolidation candidates
-        .slice(0, resolved.maxReviewBatchSize)
-        .map((s) => s.name);
-}