@the-open-engine/zeroshot 6.38.1 → 6.39.0

package/src/agent/output-extraction-json.js

@@ -0,0 +1,234 @@
+"use strict";
+function isObjectRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isProvidersParserBoundary(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        'parseProviderChunk' in value &&
+        typeof value.parseProviderChunk === 'function');
+}
+const rawProviders = require('../providers');
+if (!isProvidersParserBoundary(rawProviders)) {
+    throw new TypeError('providers module must expose parseProviderChunk');
+}
+const { parseProviderChunk } = rawProviders;
+function timestampBody(text) {
+    const match = /^\[(\d{13})\](.*)$/.exec(text);
+    return match ? (match[2] || '').trimStart() : null;
+}
+function prefixedJsonBody(text) {
+    if (text.startsWith('{') || text.startsWith('['))
+        return null;
+    const separatorIndex = text.indexOf('|');
+    if (separatorIndex < 1 || separatorIndex > 40)
+        return null;
+    const body = text.slice(separatorIndex + 1).trimStart();
+    return body.startsWith('{') || body.startsWith('[') ? body : null;
+}
+function stripTimestamp(line) {
+    if (!line || typeof line !== 'string')
+        return '';
+    const normalized = line.trim().replace(/\r$/, '');
+    if (!normalized)
+        return '';
+    const withoutTimestamp = timestampBody(normalized) ?? normalized;
+    return prefixedJsonBody(withoutTimestamp) ?? withoutTimestamp;
+}
+function parseJsonRecordLine(line) {
+    const content = stripTimestamp(line);
+    if (!content.startsWith('{'))
+        return null;
+    try {
+        const parsed = JSON.parse(content);
+        return isObjectRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractFromResultWrapper(output) {
+    for (const line of output.split('\n')) {
+        const parsed = parseJsonRecordLine(line);
+        if (parsed === null)
+            continue;
+        const extracted = extractResultContent(parsed);
+        if (extracted)
+            return extracted;
+    }
+    return null;
+}
+function extractResultContent(value) {
+    if (!isObjectRecord(value) || value.type !== 'result')
+        return null;
+    const structuredOutput = value.structured_output;
+    if (structuredOutput && typeof structuredOutput === 'object')
+        return structuredOutput;
+    const result = value.result;
+    if (!result)
+        return null;
+    if (typeof result === 'object')
+        return result;
+    if (typeof result !== 'string')
+        return null;
+    return extractFromMarkdown(result) || extractDirectJson(result);
+}
+function normalizedProviderOutput(output) {
+    const normalized = [];
+    for (const line of output.split('\n')) {
+        const content = stripTimestamp(line);
+        if (content)
+            normalized.push(content);
+    }
+    return normalized.join('\n');
+}
+function providerEventText(event) {
+    if (!isObjectRecord(event) || event.type !== 'text' || typeof event.text !== 'string') {
+        return null;
+    }
+    return event.text;
+}
+function extractTextCandidate(text) {
+    return extractDirectJson(text) || extractFromMarkdown(text);
+}
+function collectProviderText(events) {
+    const textEvents = [];
+    for (const event of events) {
+        const text = providerEventText(event);
+        if (text !== null)
+            textEvents.push(text);
+    }
+    return textEvents;
+}
+function latestTextCandidate(textEvents) {
+    for (let index = textEvents.length - 1; index >= 0; index--) {
+        const text = textEvents[index];
+        if (text === undefined)
+            continue;
+        const extracted = extractTextCandidate(text);
+        if (extracted)
+            return extracted;
+    }
+    return null;
+}
+function extractFromTextEvents(output, providerName) {
+    const events = parseProviderChunk(providerName, normalizedProviderOutput(output));
+    const textEvents = collectProviderText(events);
+    const latest = latestTextCandidate(textEvents);
+    if (latest)
+        return latest;
+    const textContent = textEvents.join('');
+    if (!textContent.trim())
+        return null;
+    return extractTextCandidate(textContent) || latestTextCandidate(textEvents);
+}
+function extractModelTextFromOutput(output, providerName) {
+    if (!output || typeof output !== 'string')
+        return null;
+    const textEvents = [];
+    const events = parseProviderChunk(providerName, normalizedProviderOutput(output));
+    for (const event of events) {
+        const text = providerEventText(event);
+        if (text !== null)
+            textEvents.push(text);
+    }
+    const text = textEvents.join('');
+    return text.trim() ? text : null;
+}
+function extractFromMarkdown(text) {
+    if (!text || typeof text !== 'string')
+        return null;
+    const match = /```json\s*([\s\S]*?)```/.exec(text);
+    const encoded = match?.[1];
+    if (encoded === undefined)
+        return null;
+    try {
+        const parsed = JSON.parse(encoded.trim());
+        return parsed !== null && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+const CLI_METADATA_FIELDS = new Set([
+    'duration_ms',
+    'duration_api_ms',
+    'total_cost_usd',
+    'session_id',
+    'num_turns',
+    'permission_denials',
+    'modelUsage',
+]);
+function isCliMetadata(value) {
+    if (value.type === 'result')
+        return true;
+    let metadataFieldCount = 0;
+    for (const key of Object.keys(value)) {
+        if (CLI_METADATA_FIELDS.has(key))
+            metadataFieldCount++;
+    }
+    return metadataFieldCount >= 2;
+}
+function extractDirectJson(text) {
+    if (!text || typeof text !== 'string')
+        return null;
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!isObjectRecord(parsed) || isCliMetadata(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function hasFatalStandaloneOutput(output) {
+    if (!output || typeof output !== 'string')
+        return false;
+    for (const line of output.split('\n')) {
+        const stripped = stripTimestamp(line).trim();
+        if (!stripped)
+            continue;
+        if (/^(task not found|process terminated)\b/i.test(stripped))
+            return true;
+    }
+    return false;
+}
+function extractJsonFromOutput(output, providerName = 'claude') {
+    if (!output || typeof output !== 'string')
+        return null;
+    const trimmedOutput = output.trim();
+    if (!trimmedOutput)
+        return null;
+    const fromWrapper = extractFromResultWrapper(trimmedOutput);
+    if (fromWrapper)
+        return fromWrapper;
+    const fromText = extractFromTextEvents(trimmedOutput, providerName);
+    if (fromText)
+        return fromText;
+    const fromMarkdown = extractFromMarkdown(trimmedOutput);
+    if (fromMarkdown)
+        return fromMarkdown;
+    const fromDirect = extractDirectJson(trimmedOutput);
+    if (fromDirect)
+        return fromDirect;
+    if (hasFatalStandaloneOutput(trimmedOutput))
+        return null;
+    return null;
+}
+module.exports = {
+    extractDirectJson,
+    extractFromMarkdown,
+    extractFromResultWrapper,
+    extractFromTextEvents,
+    extractJsonFromOutput,
+    extractModelTextFromOutput,
+    hasFatalStandaloneOutput,
+    isObjectRecord,
+    parseJsonRecordLine,
+    stripTimestamp,
+};

package/src/agent/output-extraction-json.ts

@@ -0,0 +1,235 @@
+import type { JsonRecord, ProvidersParserBoundary } from './output-extraction-types';
+
+function isObjectRecord(value: unknown): value is JsonRecord {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isProvidersParserBoundary(value: unknown): value is ProvidersParserBoundary {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    'parseProviderChunk' in value &&
+    typeof value.parseProviderChunk === 'function'
+  );
+}
+
+const rawProviders: unknown = require('../providers');
+if (!isProvidersParserBoundary(rawProviders)) {
+  throw new TypeError('providers module must expose parseProviderChunk');
+}
+const { parseProviderChunk } = rawProviders;
+
+function timestampBody(text: string): string | null {
+  const match = /^\[(\d{13})\](.*)$/.exec(text);
+  return match ? (match[2] || '').trimStart() : null;
+}
+
+function prefixedJsonBody(text: string): string | null {
+  if (text.startsWith('{') || text.startsWith('[')) return null;
+  const separatorIndex = text.indexOf('|');
+  if (separatorIndex < 1 || separatorIndex > 40) return null;
+  const body = text.slice(separatorIndex + 1).trimStart();
+  return body.startsWith('{') || body.startsWith('[') ? body : null;
+}
+
+function stripTimestamp(line: unknown): string {
+  if (!line || typeof line !== 'string') return '';
+  const normalized = line.trim().replace(/\r$/, '');
+  if (!normalized) return '';
+
+  const withoutTimestamp = timestampBody(normalized) ?? normalized;
+  return prefixedJsonBody(withoutTimestamp) ?? withoutTimestamp;
+}
+
+function parseJsonRecordLine(line: string): JsonRecord | null {
+  const content = stripTimestamp(line);
+  if (!content.startsWith('{')) return null;
+  try {
+    const parsed: unknown = JSON.parse(content);
+    return isObjectRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function extractFromResultWrapper(output: string): object | null {
+  for (const line of output.split('\n')) {
+    const parsed = parseJsonRecordLine(line);
+    if (parsed === null) continue;
+    const extracted = extractResultContent(parsed);
+    if (extracted) return extracted;
+  }
+  return null;
+}
+
+function extractResultContent(value: unknown): object | null {
+  if (!isObjectRecord(value) || value.type !== 'result') return null;
+
+  const structuredOutput = value.structured_output;
+  if (structuredOutput && typeof structuredOutput === 'object') return structuredOutput;
+
+  const result = value.result;
+  if (!result) return null;
+  if (typeof result === 'object') return result;
+  if (typeof result !== 'string') return null;
+  return extractFromMarkdown(result) || extractDirectJson(result);
+}
+
+function normalizedProviderOutput(output: string): string {
+  const normalized: string[] = [];
+  for (const line of output.split('\n')) {
+    const content = stripTimestamp(line);
+    if (content) normalized.push(content);
+  }
+  return normalized.join('\n');
+}
+
+function providerEventText(event: unknown): string | null {
+  if (!isObjectRecord(event) || event.type !== 'text' || typeof event.text !== 'string') {
+    return null;
+  }
+  return event.text;
+}
+
+function extractTextCandidate(text: string): object | null {
+  return extractDirectJson(text) || extractFromMarkdown(text);
+}
+
+function collectProviderText(events: readonly unknown[]): string[] {
+  const textEvents: string[] = [];
+  for (const event of events) {
+    const text = providerEventText(event);
+    if (text !== null) textEvents.push(text);
+  }
+  return textEvents;
+}
+
+function latestTextCandidate(textEvents: readonly string[]): object | null {
+  for (let index = textEvents.length - 1; index >= 0; index--) {
+    const text = textEvents[index];
+    if (text === undefined) continue;
+    const extracted = extractTextCandidate(text);
+    if (extracted) return extracted;
+  }
+  return null;
+}
+
+function extractFromTextEvents(output: string, providerName: string): object | null {
+  const events = parseProviderChunk(providerName, normalizedProviderOutput(output));
+  const textEvents = collectProviderText(events);
+  const latest = latestTextCandidate(textEvents);
+  if (latest) return latest;
+
+  const textContent = textEvents.join('');
+  if (!textContent.trim()) return null;
+
+  return extractTextCandidate(textContent) || latestTextCandidate(textEvents);
+}
+
+function extractModelTextFromOutput(output: unknown, providerName: string): string | null {
+  if (!output || typeof output !== 'string') return null;
+  const textEvents: string[] = [];
+  const events = parseProviderChunk(providerName, normalizedProviderOutput(output));
+  for (const event of events) {
+    const text = providerEventText(event);
+    if (text !== null) textEvents.push(text);
+  }
+  const text = textEvents.join('');
+  return text.trim() ? text : null;
+}
+
+function extractFromMarkdown(text: unknown): object | null {
+  if (!text || typeof text !== 'string') return null;
+
+  const match = /```json\s*([\s\S]*?)```/.exec(text);
+  const encoded = match?.[1];
+  if (encoded === undefined) return null;
+
+  try {
+    const parsed: unknown = JSON.parse(encoded.trim());
+    return parsed !== null && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+const CLI_METADATA_FIELDS: ReadonlySet<string> = new Set([
+  'duration_ms',
+  'duration_api_ms',
+  'total_cost_usd',
+  'session_id',
+  'num_turns',
+  'permission_denials',
+  'modelUsage',
+]);
+
+function isCliMetadata(value: JsonRecord): boolean {
+  if (value.type === 'result') return true;
+
+  let metadataFieldCount = 0;
+  for (const key of Object.keys(value)) {
+    if (CLI_METADATA_FIELDS.has(key)) metadataFieldCount++;
+  }
+  return metadataFieldCount >= 2;
+}
+
+function extractDirectJson(text: unknown): JsonRecord | null {
+  if (!text || typeof text !== 'string') return null;
+
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+
+  try {
+    const parsed: unknown = JSON.parse(trimmed);
+    if (!isObjectRecord(parsed) || isCliMetadata(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function hasFatalStandaloneOutput(output: unknown): boolean {
+  if (!output || typeof output !== 'string') return false;
+  for (const line of output.split('\n')) {
+    const stripped = stripTimestamp(line).trim();
+    if (!stripped) continue;
+    if (/^(task not found|process terminated)\b/i.test(stripped)) return true;
+  }
+  return false;
+}
+
+function extractJsonFromOutput(output: unknown, providerName = 'claude'): object | null {
+  if (!output || typeof output !== 'string') return null;
+
+  const trimmedOutput = output.trim();
+  if (!trimmedOutput) return null;
+
+  const fromWrapper = extractFromResultWrapper(trimmedOutput);
+  if (fromWrapper) return fromWrapper;
+
+  const fromText = extractFromTextEvents(trimmedOutput, providerName);
+  if (fromText) return fromText;
+
+  const fromMarkdown = extractFromMarkdown(trimmedOutput);
+  if (fromMarkdown) return fromMarkdown;
+
+  const fromDirect = extractDirectJson(trimmedOutput);
+  if (fromDirect) return fromDirect;
+
+  if (hasFatalStandaloneOutput(trimmedOutput)) return null;
+  return null;
+}
+
+export = {
+  extractDirectJson,
+  extractFromMarkdown,
+  extractFromResultWrapper,
+  extractFromTextEvents,
+  extractJsonFromOutput,
+  extractModelTextFromOutput,
+  hasFatalStandaloneOutput,
+  isObjectRecord,
+  parseJsonRecordLine,
+  stripTimestamp,
+};

package/src/agent/output-extraction-pi.js

@@ -0,0 +1,124 @@
+"use strict";
+const errorDetail = require("./output-extraction-error-detail");
+const jsonExtraction = require("./output-extraction-json");
+const { cliErrorDetail } = errorDetail;
+const { isObjectRecord, stripTimestamp } = jsonExtraction;
+const PI_STOP_REASONS = new Set([
+    'stop',
+    'length',
+    'toolUse',
+    'error',
+    'aborted',
+    'deferred',
+]);
+const PI_USAGE_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'totalTokens'];
+const PI_COST_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'total'];
+function piProtocolFailure(message) {
+    return { ...cliErrorDetail(message, message), provider: 'pi' };
+}
+function parsePiProtocolObject(content) {
+    if (!content.startsWith('{'))
+        return null;
+    try {
+        const parsed = JSON.parse(content);
+        return isObjectRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function hasPiNumericFields(value, fields) {
+    return isObjectRecord(value) && fields.every((field) => typeof value[field] === 'number');
+}
+function isValidPiUsage(usage) {
+    if (!hasPiNumericFields(usage, PI_USAGE_FIELDS))
+        return false;
+    if (!hasPiNumericFields(usage.cost, PI_COST_FIELDS))
+        return false;
+    return ((usage.cacheWrite1h === undefined || typeof usage.cacheWrite1h === 'number') &&
+        (usage.reasoning === undefined || typeof usage.reasoning === 'number'));
+}
+function isValidPiAssistantMessage(message) {
+    return (isObjectRecord(message) &&
+        message.role === 'assistant' &&
+        Array.isArray(message.content) &&
+        isValidPiUsage(message.usage) &&
+        typeof message.stopReason === 'string' &&
+        PI_STOP_REASONS.has(message.stopReason));
+}
+function piMessageRole(message) {
+    if (!isObjectRecord(message))
+        return null;
+    return typeof message.role === 'string' ? message.role : null;
+}
+function piFailureFromMessage(message) {
+    const stopReason = message.stopReason;
+    const errorMessage = message.errorMessage;
+    if (stopReason === 'deferred') {
+        return {
+            ...cliErrorDetail('Pi turn deferred without completing.', 'Pi turn deferred'),
+            provider: 'pi',
+        };
+    }
+    if (stopReason !== 'error' && stopReason !== 'aborted' && !errorMessage)
+        return null;
+    return {
+        ...cliErrorDetail(errorMessage || stopReason, 'Pi turn failed'),
+        provider: 'pi',
+    };
+}
+function isIgnoredPiLine(content) {
+    return (content.startsWith('[ZEROSHOT] Earlier provider output omitted') ||
+        content.startsWith('[ZEROSHOT] Provider output record retained') ||
+        content.startsWith('[ZEROSHOT][PROVIDER_STDERR] '));
+}
+function applyPiMessageEnd(message, state) {
+    const role = piMessageRole(message);
+    if (role === null)
+        return piProtocolFailure('Pi message_end did not contain a valid message.');
+    if (role !== 'assistant')
+        return null;
+    if (!isValidPiAssistantMessage(message)) {
+        return piProtocolFailure('Pi message_end did not contain a valid assistant message.');
+    }
+    state.latestAssistant = message;
+    return null;
+}
+function applyPiEvent(parsed, state) {
+    if (typeof parsed.type !== 'string') {
+        return piProtocolFailure('Pi JSON stream contained an event without a valid type.');
+    }
+    if (parsed.type === 'message_end')
+        return applyPiMessageEnd(parsed.message, state);
+    if (parsed.type === 'agent_settled')
+        state.settled = true;
+    return null;
+}
+function applyPiProtocolLine(content, state) {
+    if (!content || isIgnoredPiLine(content))
+        return null;
+    if (state.settled)
+        return piProtocolFailure('Pi emitted output after agent_settled.');
+    const parsed = parsePiProtocolObject(content);
+    if (parsed === null)
+        return piProtocolFailure('Pi JSON stream contained malformed output.');
+    return applyPiEvent(parsed, state);
+}
+function extractSettledPiFailure(lines) {
+    const state = { latestAssistant: null, settled: false };
+    for (const line of lines) {
+        const content = stripTimestamp(line);
+        const failure = applyPiProtocolLine(content, state);
+        if (failure)
+            return failure;
+    }
+    if (!state.settled)
+        return piProtocolFailure('Pi JSON stream ended before agent_settled.');
+    if (state.latestAssistant === null) {
+        return piProtocolFailure('Pi settled without a valid assistant message_end.');
+    }
+    return piFailureFromMessage(state.latestAssistant);
+}
+module.exports = {
+    extractSettledPiFailure,
+};