oh-my-knowledge 0.51.1 → 0.52.0

package/dist/observability/codex-protocol.js

@@ -0,0 +1,78 @@
+/** Stable inventory of Codex rollout record shapes understood by OMK. */
+const RESPONSE_ITEM_TYPES = new Set([
+    'message',
+    'reasoning',
+    'tool_search_call',
+    'tool_search_output',
+    'web_search_call',
+    'image_generation_call',
+    'function_call',
+    'custom_tool_call',
+    'function_call_output',
+    'custom_tool_call_output',
+    'agent_message',
+]);
+const EVENT_MESSAGE_TYPES = new Set([
+    'token_count',
+    'task_started',
+    'task_complete',
+    'turn_aborted',
+    'turn_interrupted',
+    'user_message',
+    'agent_message',
+    'mcp_tool_call_end',
+    'patch_apply_end',
+    'agent_reasoning',
+    'thread_settings_applied',
+    'web_search_end',
+    'context_compacted',
+    'image_generation_end',
+    'thread_goal_updated',
+    'sub_agent_activity',
+]);
+const IN_APP_BROWSER_CONTEXT_RE = /<in-app-browser-context\b[^>]*>[\s\S]*?<\/in-app-browser-context>/gi;
+const CODEX_RUNTIME_MESSAGE_RE = /^# AGENTS\.md instructions\b|^<(?:app-context|environment_context|permissions instructions|collaboration_mode|apps_instructions|plugins_instructions|skills_instructions|recommended_plugins)>/i;
+export function isCodexResponseItemType(value) {
+    return value !== undefined && RESPONSE_ITEM_TYPES.has(value);
+}
+export function isCodexEventMessageType(value) {
+    return value !== undefined && EVENT_MESSAGE_TYPES.has(value);
+}
+/** Preserve source text separately while removing Codex UI transport envelopes from semantic display. */
+export function codexUserDisplayText(text) {
+    const requestHeading = /^## My request for Codex:\s*$/im;
+    const requestMatch = requestHeading.exec(text);
+    const request = requestMatch
+        ? text.slice(requestMatch.index + requestMatch[0].length)
+        : text;
+    const visible = request
+        .replace(IN_APP_BROWSER_CONTEXT_RE, ' ')
+        .replace(/<image\b[^>]*>[\s\S]*?<\/image>/gi, ' ')
+        .replace(/\[Image\s+#\d+\]/gi, ' ')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return visible || undefined;
+}
+export function codexUserMessageOrigin(text) {
+    const trimmed = text.trimStart();
+    if (CODEX_RUNTIME_MESSAGE_RE.test(trimmed))
+        return 'runtime';
+    if (/^<in-app-browser-context\b/i.test(trimmed) && !codexUserDisplayText(text))
+        return 'runtime';
+    return 'human';
+}
+/**
+ * Records consumed by correlation or retained only as source provenance do not
+ * emit a standalone Trace IR event. Keeping this inventory explicit preserves
+ * `unknown` as a forward-compatibility warning.
+ */
+export function isCodexRecordConsumedWithoutDirectEvent(recordType, payloadType) {
+    if (recordType === 'world_state')
+        return true;
+    if (recordType === 'inter_agent_communication_metadata')
+        return true;
+    if (recordType !== 'event_msg')
+        return false;
+    return payloadType === 'web_search_end'
+        || payloadType === 'image_generation_end';
+}

package/dist/observability/codex-tool-status.d.ts

@@ -0,0 +1,16 @@
+import type { TraceToolStatus } from './trace-ir.js';
+export interface CodexToolOutcome {
+    status: TraceToolStatus;
+    present: boolean;
+}
+/** Normalize Codex status values before source adapters project Trace IR. */
+export declare function codexToolStatusFromValue(value: unknown): TraceToolStatus;
+/** Runtime end records are authoritative even when they only expose an Ok/Err envelope. */
+export declare function codexRuntimeToolOutcome(end: {
+    status?: unknown;
+    isError?: boolean;
+} | undefined): CodexToolOutcome;
+/** Extract the same authoritative outcome from a raw Codex runtime-end payload. */
+export declare function codexRuntimeToolOutcomeFromPayload(payloadType: string | undefined, payload: Record<string, unknown>): CodexToolOutcome;
+/** Infer bridge output status only when Codex did not record an explicit status. */
+export declare function codexToolOutputOutcome(output: unknown, explicitStatus?: unknown): CodexToolOutcome;

package/dist/observability/codex-tool-status.js

@@ -0,0 +1,114 @@
+import { isToolResultFailureText } from './text-signals.js';
+/** Normalize Codex status values before source adapters project Trace IR. */
+export function codexToolStatusFromValue(value) {
+    const status = stringValue(value)?.toLowerCase();
+    if (status === 'failed' || status === 'error')
+        return 'failure';
+    if (status === 'cancelled' || status === 'canceled')
+        return 'cancelled';
+    if (status === 'success' || status === 'succeeded' || status === 'completed' || status === 'complete') {
+        return 'success';
+    }
+    return 'unknown';
+}
+/** Runtime end records are authoritative even when they only expose an Ok/Err envelope. */
+export function codexRuntimeToolOutcome(end) {
+    if (!end)
+        return { status: 'unknown', present: false };
+    if (end.status !== undefined) {
+        const status = codexToolStatusFromValue(end.status);
+        if (status === 'cancelled')
+            return { status, present: true };
+        if (status === 'failure' || end.isError === true) {
+            return { status: 'failure', present: true };
+        }
+        if (status === 'success')
+            return { status, present: true };
+        return { status: 'unknown', present: true };
+    }
+    if (end.isError === true)
+        return { status: 'failure', present: true };
+    if (end.isError === false)
+        return { status: 'success', present: true };
+    return { status: 'unknown', present: false };
+}
+/** Extract the same authoritative outcome from a raw Codex runtime-end payload. */
+export function codexRuntimeToolOutcomeFromPayload(payloadType, payload) {
+    if (payloadType === 'patch_apply_end') {
+        const success = booleanValue(payload.success);
+        return codexRuntimeToolOutcome({
+            status: payload.status,
+            isError: success === undefined ? undefined : !success,
+        });
+    }
+    if (payloadType !== 'mcp_tool_call_end')
+        return { status: 'unknown', present: false };
+    const result = objectValue(payload.result) ?? {};
+    const hasOk = Object.prototype.hasOwnProperty.call(result, 'Ok');
+    const ok = objectValue(result.Ok);
+    const hasErr = Object.prototype.hasOwnProperty.call(result, 'Err');
+    const isError = booleanValue(payload.isError)
+        ?? booleanValue(payload.is_error)
+        ?? booleanValue(result.isError)
+        ?? booleanValue(result.is_error)
+        ?? booleanValue(ok?.isError)
+        ?? booleanValue(ok?.is_error)
+        ?? (hasErr ? true : hasOk ? false : undefined);
+    return codexRuntimeToolOutcome({
+        status: payload.status ?? result.status ?? ok?.status,
+        isError,
+    });
+}
+/** Infer bridge output status only when Codex did not record an explicit status. */
+export function codexToolOutputOutcome(output, explicitStatus) {
+    if (explicitStatus !== undefined) {
+        return { status: codexToolStatusFromValue(explicitStatus), present: true };
+    }
+    const text = toolOutputText(output);
+    if (codexToolOutputFailed(text)) {
+        return { status: 'failure', present: true };
+    }
+    if (codexToolOutputSucceeded(text))
+        return { status: 'success', present: true };
+    if (isToolResultFailureText(output))
+        return { status: 'failure', present: true };
+    return { status: 'unknown', present: false };
+}
+function codexToolOutputFailed(output) {
+    return /\b(?:process|script)\s+(?:exited|failed)\s+with\s+(?:exit\s+)?code\s+[1-9]\d*\b/i.test(output)
+        || /\bexit[_\s-]?code\s*[:=]\s*[1-9]\d*\b/i.test(output)
+        || /\bapply_patch verification failed\b/i.test(output);
+}
+function codexToolOutputSucceeded(output) {
+    const trimmed = output.trim();
+    return /\bprocess exited with code 0\b/i.test(trimmed)
+        || /\bexit code:\s*0\b/i.test(trimmed)
+        || /^script completed\b/i.test(trimmed)
+        || /^success\.\s+(?:updated|added|deleted|moved)\b/i.test(trimmed)
+        || /^plan updated\b/i.test(trimmed)
+        || /^workspace dependencies are available\b/i.test(trimmed)
+        || /^\[image\]$/i.test(trimmed);
+}
+function toolOutputText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === undefined || value === null)
+        return '';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function objectValue(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}