@abot-ai/runtime 1.0.0

package/dist/src/runtime/events/event-status.js

@@ -0,0 +1,298 @@
+import { formatDevelopmentProgressTitle, formatPlannerPlanItemEventTitle, formatPlannerPlanTitle, } from "./planner-event-status.js";
+const ACTION_LINE_PREFIX_BY_TYPE = {
+    mkdir: "created folder",
+    inspect_target: "read target",
+    establish_target: "established target",
+    refine_target: "updated target",
+    state_already_satisfied: "already up to date",
+};
+export function formatToolDisplayName(tool) {
+    return tool.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function withStatus(payload, status, message) {
+    return {
+        ...payload,
+        status,
+        message: message ?? status,
+    };
+}
+function withRuntimeStateDetails(payload, status, message) {
+    void payload;
+    return { status, message };
+}
+function formatActionLine(action) {
+    const prefix = action.type
+        ? ACTION_LINE_PREFIX_BY_TYPE[action.type]
+        : undefined;
+    if (prefix && action.target) {
+        return `${prefix}: ${action.target}`;
+    }
+    if (action.type && action.target) {
+        return `${action.type.replace(/_/g, " ")}: ${action.target}`;
+    }
+    if (action.details) {
+        return `action: ${action.details}`;
+    }
+    return "action: unknown";
+}
+function readToolDisplaySummary(payload) {
+    const meta = payload.meta;
+    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+        return undefined;
+    }
+    const value = meta.displaySummary;
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.replace(/\s+/gu, " ").trim();
+    if (!normalized) {
+        return undefined;
+    }
+    const maxLength = 500;
+    return normalized.length <= maxLength
+        ? normalized
+        : `${normalized.slice(0, maxLength - 3)}...`;
+}
+function getToolStartedStatus(tool) {
+    const displayName = formatToolDisplayName(tool);
+    return {
+        status: `${displayName}: started`,
+        message: `${displayName}...`,
+    };
+}
+function getToolCompletedStatus(tool, ok) {
+    const displayName = formatToolDisplayName(tool);
+    return {
+        status: `${displayName}: ${ok ? "complete" : "failed"}`,
+        messageHeader: `${displayName} ${ok ? "complete" : "failed"}`,
+    };
+}
+function formatRuntimeStateStatus(payload) {
+    if (typeof payload.message === "string" &&
+        payload.message.trim().length > 0) {
+        return withRuntimeStateDetails(payload, payload.message, payload.message);
+    }
+    const stage = typeof payload.stage === "string" ? payload.stage : "";
+    const phase = typeof payload.phase === "string" ? payload.phase : "";
+    if (stage === "task_progress") {
+        if (phase === "summarizing") {
+            return withRuntimeStateDetails(payload, "Checking task progress...", "Reviewing recent tool results and updating the task checklist...");
+        }
+        if (phase === "completed") {
+            return withRuntimeStateDetails(payload, "Task progress updated");
+        }
+        if (phase === "failed") {
+            return withRuntimeStateDetails(payload, "Task progress check skipped");
+        }
+    }
+    if (stage === "planned_work_review") {
+        if (phase === "started") {
+            return withRuntimeStateDetails(payload, "Reviewing completed work...");
+        }
+        if (phase === "passed") {
+            return withRuntimeStateDetails(payload, "Completion review passed");
+        }
+        if (phase === "gaps_found") {
+            return withRuntimeStateDetails(payload, "Completion review found gaps");
+        }
+        if (phase === "limit_reached") {
+            return withRuntimeStateDetails(payload, "Completion review limit reached");
+        }
+    }
+    if (stage === "decision_recovery") {
+        if (phase === "strict_retry") {
+            return withRuntimeStateDetails(payload, "Retrying with stricter instructions...", "The previous decision was not usable, so the runtime is asking for a stricter tool or final answer.");
+        }
+        if (phase === "forced_pre_tool") {
+            return withRuntimeStateDetails(payload, "Forcing a valid next action...", "The runtime is correcting an invalid first step before any tool work continues.");
+        }
+    }
+    if (stage === "loop_recovery") {
+        if (phase === "recap") {
+            return withRuntimeStateDetails(payload, "Recovering task context...", "Building a recap from completed work and latest grounded state before trying again.");
+        }
+        if (phase === "completed") {
+            return withRuntimeStateDetails(payload, "Recovery completed");
+        }
+        if (phase === "degraded") {
+            return withRuntimeStateDetails(payload, "Recovery still blocked");
+        }
+    }
+    if (stage === "runtime_degraded") {
+        return withRuntimeStateDetails(payload, "Work paused");
+    }
+    if (stage === "round_limit") {
+        return withRuntimeStateDetails(payload, "Round limit reached");
+    }
+    if (stage === "interaction_mode") {
+        return withRuntimeStateDetails(payload, "Checking request mode...");
+    }
+    if (stage === "context_build") {
+        return withRuntimeStateDetails(payload, "Preparing context...");
+    }
+    if (stage === "chat_final") {
+        return withRuntimeStateDetails(payload, "Drafting response...");
+    }
+    if (stage === "chat_finalization") {
+        return withRuntimeStateDetails(payload, "Finalizing response...");
+    }
+    if (stage === "tool_loop") {
+        if (!phase) {
+            return withRuntimeStateDetails(payload, "Starting tool work...");
+        }
+        if (phase === "pre_tool") {
+            return withRuntimeStateDetails(payload, "Choosing the next action...");
+        }
+        if (phase === "post_tool") {
+            return withRuntimeStateDetails(payload, "Checking the latest tool result...");
+        }
+    }
+    if (stage === "finalization") {
+        return withRuntimeStateDetails(payload, "Preparing final answer...");
+    }
+    if (stage === "timeout") {
+        return withRuntimeStateDetails(payload, "Request timed out");
+    }
+    if (stage) {
+        return withRuntimeStateDetails(payload, phase ? `${stage}: ${phase}` : stage);
+    }
+    return withRuntimeStateDetails(payload, "Runtime update");
+}
+function withSingleLineEventTitle(payload, title) {
+    const { status: _status, message: _message, ...rest } = payload;
+    void _status;
+    void _message;
+    return {
+        ...rest,
+        name: title,
+    };
+}
+function withoutDuplicateDisplayText(payload) {
+    const { status: _status, message: _message, ...rest } = payload;
+    void _status;
+    void _message;
+    return rest;
+}
+export function enrichEventPayload(payload) {
+    if (payload.type !== "event") {
+        return payload;
+    }
+    const name = typeof payload.name === "string" ? payload.name : "";
+    const tool = typeof payload.tool === "string" ? payload.tool : "";
+    if (name === "thinking.started" || name === "thinking.delta") {
+        return withoutDuplicateDisplayText(payload);
+    }
+    if (name === "thinking.completed") {
+        return withoutDuplicateDisplayText(payload);
+    }
+    if (name === "runtime.state") {
+        const runtimeStatus = formatRuntimeStateStatus(payload);
+        return withSingleLineEventTitle(payload, runtimeStatus.status);
+    }
+    if (name === "context.tools.compact") {
+        const trigger = typeof payload.compactTrigger === "string" ? payload.compactTrigger : "";
+        const status = trigger === "baseline_worker_profile"
+            ? "Using compact tool list"
+            : "Using compact tool list again";
+        return withStatus(payload, status, "The model is receiving the compact tool registry profile. No hidden conversation content is shown.");
+    }
+    if (name === "context.compaction.started") {
+        return withStatus(payload, "Compacting context...", "Preparing a smaller context projection while preserving active request state...");
+    }
+    if (name === "context.compaction.completed") {
+        return withStatus(payload, "Context compacted", "The active request context was compacted successfully.");
+    }
+    if (name === "context.compaction.failed") {
+        return withStatus(payload, "Context compaction failed", "The active request context could not be reduced safely.");
+    }
+    if (name === "planner.plan.created" || name === "planner.plan.updated") {
+        return withSingleLineEventTitle(payload, formatPlannerPlanTitle(payload));
+    }
+    if (name === "development.progress.updated") {
+        return withSingleLineEventTitle(payload, formatDevelopmentProgressTitle(payload));
+    }
+    if (name === "planner.plan.item.planned") {
+        return withSingleLineEventTitle(payload, formatPlannerPlanItemEventTitle("planned", payload));
+    }
+    if (name === "planner.plan.item.completed") {
+        return withSingleLineEventTitle(payload, formatPlannerPlanItemEventTitle("completed", payload));
+    }
+    if (name === "planner.plan.item.blocked") {
+        return withSingleLineEventTitle(payload, formatPlannerPlanItemEventTitle("blocked", payload));
+    }
+    if (name === "planner.plan.item.started") {
+        return withSingleLineEventTitle(payload, formatPlannerPlanItemEventTitle("started", payload));
+    }
+    if (name === "planner.plan.item.reopened") {
+        return withSingleLineEventTitle(payload, formatPlannerPlanItemEventTitle("reopened", payload));
+    }
+    if (name === "tool.started") {
+        const explicitStatus = typeof payload.status === "string" ? payload.status.trim() : "";
+        if (explicitStatus) {
+            const explicitMessage = typeof payload.message === "string" && payload.message.trim()
+                ? payload.message.trim()
+                : explicitStatus;
+            return withStatus(payload, explicitStatus, explicitMessage);
+        }
+        if (!tool) {
+            return withStatus(payload, "Tool started");
+        }
+        const status = getToolStartedStatus(tool);
+        return withStatus(payload, status.status, status.message);
+    }
+    if (name === "tool.approval.required") {
+        const displayName = tool ? formatToolDisplayName(tool) : "Tool";
+        return withStatus(payload, `${displayName}: approval required`, `${displayName}: Waiting for approval`);
+    }
+    if (name === "tool.approval.granted") {
+        const displayName = tool ? formatToolDisplayName(tool) : "Tool";
+        return withStatus(payload, `${displayName}: approved`, `${displayName}: Approved`);
+    }
+    if (name === "tool.approval.rejected") {
+        const displayName = tool ? formatToolDisplayName(tool) : "Tool";
+        return withStatus(payload, `${displayName}: rejected`, `${displayName}: Rejected`);
+    }
+    if (name === "tool.payload.started") {
+        if (!tool) {
+            return withStatus(payload, "Generating payload...", "Generating payload...");
+        }
+        const displayName = formatToolDisplayName(tool);
+        return withStatus(payload, `${displayName}: generating payload`, `${displayName}: Generating payload...`);
+    }
+    if (name === "tool.payload.completed") {
+        if (!tool) {
+            return withStatus(payload, "Payload ready");
+        }
+        const displayName = formatToolDisplayName(tool);
+        return withStatus(payload, `${displayName}: payload ready`, `${displayName}: Payload ready`);
+    }
+    if (name === "tool.payload.failed") {
+        if (!tool) {
+            return withStatus(payload, "Payload generation failed");
+        }
+        const displayName = formatToolDisplayName(tool);
+        return withStatus(payload, `${displayName}: payload failed`, `${displayName}: Payload generation failed`);
+    }
+    if (name === "tool.completed") {
+        if (!tool) {
+            return withStatus(payload, "Tool completed");
+        }
+        const ok = payload.ok === true;
+        const explicitStatus = typeof payload.status === "string" ? payload.status.trim() : "";
+        const explicitMessage = typeof payload.message === "string" ? payload.message.trim() : "";
+        const status = explicitStatus
+            ? {
+                status: explicitStatus,
+                messageHeader: explicitMessage || explicitStatus,
+            }
+            : getToolCompletedStatus(tool, ok);
+        const displaySummary = readToolDisplaySummary(payload);
+        const actionLines = Array.isArray(payload.actions)
+            ? payload.actions.map(formatActionLine)
+            : [];
+        return withStatus(payload, status.status, [status.messageHeader, displaySummary, ...actionLines]
+            .filter((line) => typeof line === "string")
+            .join("\n"));
+    }
+    return payload;
+}

package/dist/src/runtime/events/planner-event-status.d.ts

@@ -0,0 +1,9 @@
+type PlannerEventPayload = {
+    plan?: unknown;
+    item?: unknown;
+    [key: string]: unknown;
+};
+export declare function formatPlannerPlanTitle(payload: PlannerEventPayload): string;
+export declare function formatDevelopmentProgressTitle(payload: PlannerEventPayload): string;
+export declare function formatPlannerPlanItemEventTitle(action: "planned" | "started" | "completed" | "blocked" | "reopened", payload: PlannerEventPayload): string;
+export {};

package/dist/src/runtime/events/planner-event-status.js

@@ -0,0 +1,56 @@
+function getRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function getNumber(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function getPlannerPlanDetails(payload) {
+    const plan = getRecord(payload.plan);
+    if (!plan) {
+        return {
+            summary: "",
+            total: 0,
+            completed: 0,
+            items: [],
+        };
+    }
+    const items = Array.isArray(plan.items)
+        ? plan.items.flatMap((item) => {
+            const record = getRecord(item);
+            if (!record || typeof record.title !== "string") {
+                return [];
+            }
+            return [
+                {
+                    title: record.title,
+                    status: typeof record.status === "string" ? record.status : "pending",
+                },
+            ];
+        })
+        : [];
+    const completed = getNumber(plan.completed, items.filter((item) => item.status === "done").length);
+    return {
+        summary: typeof plan.summary === "string" ? plan.summary : "",
+        total: getNumber(plan.total, items.length),
+        completed,
+        items,
+    };
+}
+export function formatPlannerPlanTitle(payload) {
+    const plan = getPlannerPlanDetails(payload);
+    return `Planner plan: ${plan.completed}/${plan.total} complete`;
+}
+export function formatDevelopmentProgressTitle(payload) {
+    const plan = getPlannerPlanDetails(payload);
+    return `Development progress: ${plan.completed}/${plan.total} complete`;
+}
+function getPlannerPlanItemTitle(payload) {
+    const item = getRecord(payload.item);
+    const title = typeof item?.title === "string" ? item.title.trim() : "";
+    return title || "planned task";
+}
+export function formatPlannerPlanItemEventTitle(action, payload) {
+    return `Planner ${action}: ${getPlannerPlanItemTitle(payload)}`;
+}

package/dist/src/runtime/events/runtime-emitter.d.ts

@@ -0,0 +1,30 @@
+import type WebSocket from "ws";
+import type { RequestLifecycleState } from "../orchestration/lifecycle/request-lifecycle.js";
+export type RuntimeEventPersist = (payload: Record<string, unknown>) => Promise<unknown>;
+type RuntimeEventBusOptions = {
+    requestId: string;
+    ws: WebSocket;
+    persist?: RuntimeEventPersist;
+};
+export declare class RuntimeEventBus {
+    private readonly options;
+    private persistQueue;
+    private disposed;
+    private eventSequence;
+    constructor(options: RuntimeEventBusOptions);
+    publish(payload: Record<string, unknown>): void;
+    event(name: string, extra?: Record<string, unknown>): void;
+    runtimeState(state: RequestLifecycleState): void;
+    token(token: string): void;
+    legacyToken(text: string): void;
+    thinkingDelta(delta: string, accumulatedText: string): void;
+    completed(output: string): void;
+    failed(error: string, details?: Record<string, unknown>): void;
+    drain(): Promise<void>;
+    dispose(): void;
+    private withRequestId;
+    private withEventSequence;
+    private persistIfNeeded;
+}
+export declare function createRuntimeEventBus(options: RuntimeEventBusOptions): RuntimeEventBus;
+export {};

package/dist/src/runtime/events/runtime-emitter.js

@@ -0,0 +1,186 @@
+import { traceDebug } from "../observability/debug-logger.js";
+import { enrichEventPayload } from "./event-status.js";
+function isReplayableRequestPayload(payload) {
+    const type = typeof payload.type === "string" ? payload.type : "";
+    const name = typeof payload.name === "string" ? payload.name : "";
+    if (type === "event" && name === "token") {
+        return false;
+    }
+    return (type === "event" ||
+        type === "token" ||
+        type === "completed" ||
+        type === "failed");
+}
+function payloadRequestId(payload) {
+    return typeof payload.requestId === "string" ? payload.requestId : "";
+}
+function boundedControlValue(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    return /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(value) ? value : undefined;
+}
+function logOutboundEventPayload(rawPayload, enrichedPayload) {
+    const type = typeof rawPayload.type === "string" ? rawPayload.type : "";
+    if (type !== "event") {
+        return;
+    }
+    const rawName = typeof rawPayload.name === "string" ? rawPayload.name : "";
+    if (rawName === "thinking.delta" || rawName === "token") {
+        return;
+    }
+    const emittedName = typeof enrichedPayload.name === "string" ? enrichedPayload.name : "";
+    // Streaming deltas are delivered to the UI, but are intentionally not traced
+    // one-by-one. Model gateway completion and finalized thinking events already
+    // provide bounded stream-level diagnostics. Event content remains available
+    // to the client and persistence path; the trace records only control-plane
+    // metadata so user and role content cannot leak through display enrichment.
+    traceDebug("runtime.emitter", "ui.event.emit", {
+        requestId: payloadRequestId(rawPayload) || undefined,
+        rawName: boundedControlValue(rawName),
+        rawNameLength: rawName.length,
+        emittedNameChanged: emittedName !== rawName,
+        emittedNameLength: emittedName.length,
+        eventSequence: typeof enrichedPayload.eventSequence === "number"
+            ? enrichedPayload.eventSequence
+            : undefined,
+        stage: boundedControlValue(enrichedPayload.stage),
+        phase: boundedControlValue(enrichedPayload.phase),
+        payloadFieldCount: Object.keys(enrichedPayload).length,
+    });
+}
+function isInternalLifecycleEvent(name) {
+    return name === "thinking.started" || name === "thinking.completed";
+}
+export class RuntimeEventBus {
+    options;
+    persistQueue = Promise.resolve();
+    disposed = false;
+    eventSequence = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    publish(payload) {
+        const outboundPayload = this.withEventSequence(this.withRequestId(payload));
+        const enrichedPayload = enrichEventPayload(outboundPayload);
+        this.persistIfNeeded(enrichedPayload);
+        logOutboundEventPayload(outboundPayload, enrichedPayload);
+        this.options.ws.send(JSON.stringify(enrichedPayload));
+    }
+    event(name, extra = {}) {
+        if (isInternalLifecycleEvent(name)) {
+            traceDebug("runtime.emitter", "internal.event", {
+                requestId: this.options.requestId || undefined,
+                name,
+                payload: extra,
+            });
+            return;
+        }
+        this.publish({
+            type: "event",
+            requestId: this.options.requestId,
+            name,
+            ...extra,
+        });
+    }
+    runtimeState(state) {
+        const details = formatRuntimeStateDetails(state);
+        traceDebug("runtime.emitter", "runtime.state", {
+            requestId: this.options.requestId || undefined,
+            state,
+            details: details || undefined,
+        });
+    }
+    token(token) {
+        this.event("token", { text: token });
+    }
+    legacyToken(text) {
+        this.publish({ type: "token", requestId: this.options.requestId, text });
+    }
+    thinkingDelta(delta, accumulatedText) {
+        this.event("thinking.delta", {
+            delta,
+            text: accumulatedText,
+        });
+    }
+    completed(output) {
+        this.publish({
+            type: "completed",
+            requestId: this.options.requestId,
+            output,
+        });
+    }
+    failed(error, details) {
+        this.publish({
+            type: "failed",
+            requestId: this.options.requestId,
+            error,
+            ...(details ? { details } : {}),
+        });
+    }
+    async drain() {
+        await this.persistQueue;
+    }
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+    }
+    withRequestId(payload) {
+        if (payloadRequestId(payload) || !this.options.requestId) {
+            return payload;
+        }
+        return { ...payload, requestId: this.options.requestId };
+    }
+    withEventSequence(payload) {
+        this.eventSequence += 1;
+        return { ...payload, eventSequence: this.eventSequence };
+    }
+    persistIfNeeded(payload) {
+        if (!this.options.persist || !isReplayableRequestPayload(payload)) {
+            return;
+        }
+        this.persistQueue = this.persistQueue
+            .then(async () => {
+            await this.options.persist?.(payload);
+        })
+            .catch((error) => {
+            traceDebug("runtime.emitter", "request_event_persist_failed", {
+                requestId: this.options.requestId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
+}
+export function createRuntimeEventBus(options) {
+    return new RuntimeEventBus(options);
+}
+function friendlyRuntimeReason(reason) {
+    switch (reason) {
+        case "selection":
+            return "previous choice was not usable";
+        case "no_progress":
+            return "no new progress was detected";
+        case "invalid_final_output":
+            return "the final response was not usable yet";
+        default:
+            return reason.replace(/_/g, " ");
+    }
+}
+function formatRuntimeStateDetails(state) {
+    return [
+        state.reason ? friendlyRuntimeReason(state.reason) : "",
+        typeof state.attempt === "number"
+            ? `recovery attempt ${state.attempt}`
+            : "",
+        typeof state.toolIteration === "number"
+            ? `tool step ${state.toolIteration}`
+            : "",
+        typeof state.decisionAttemptCount === "number"
+            ? `decision attempt ${state.decisionAttemptCount}`
+            : "",
+    ]
+        .filter((part) => part.length > 0)
+        .join(", ");
+}

package/dist/src/runtime/events/runtime-status.d.ts

@@ -0,0 +1,5 @@
+import type { RequestLifecycleState } from "../orchestration/lifecycle/request-lifecycle.js";
+import type { RequestExecutionSeed } from "../request/contracts.js";
+type RuntimeStatusTarget = Pick<RequestExecutionSeed, "onEvent">;
+export declare function emitRuntimeStatus(request: RuntimeStatusTarget, state: RequestLifecycleState): void;
+export {};

package/dist/src/runtime/events/runtime-status.js

@@ -0,0 +1,3 @@
+export function emitRuntimeStatus(request, state) {
+    request.onEvent("runtime.state", state);
+}

package/dist/src/runtime/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./ports.js";
+export * from "./config.js";
+export * from "./default-adapters.js";
+export * from "./composition.js";
+export * from "./adapters/configured-skill-provider.js";
+export * from "./adapters/compiled-workspace-provider.js";
+export * from "./adapters/file-session-store.js";
+export * from "./adapters/in-memory-session-store.js";
+export * from "./adapters/multi-workspace-provider.js";
+export * from "./adapters/source-workspace-provider.js";
+export * from "./attachments/store.js";
+export * from "./observability/debug-logger.js";

package/dist/src/runtime/index.js

@@ -0,0 +1,12 @@
+export * from "./ports.js";
+export * from "./config.js";
+export * from "./default-adapters.js";
+export * from "./composition.js";
+export * from "./adapters/configured-skill-provider.js";
+export * from "./adapters/compiled-workspace-provider.js";
+export * from "./adapters/file-session-store.js";
+export * from "./adapters/in-memory-session-store.js";
+export * from "./adapters/multi-workspace-provider.js";
+export * from "./adapters/source-workspace-provider.js";
+export * from "./attachments/store.js";
+export * from "./observability/debug-logger.js";

package/dist/src/runtime/lifecycle/request-finalizer.d.ts

@@ -0,0 +1,30 @@
+import type { SessionThinkingTraceEntry } from "../../sessions/types.js";
+import type { AgentMode } from "../../shared/types.js";
+import type { EventSink } from "../ports.js";
+import { RequestLifecycle } from "../orchestration/lifecycle/request-lifecycle.js";
+import type { RequestObservation, RequestOutputTextMode } from "../request/result.js";
+import type { RequestSessionStore } from "../request/session-store.js";
+type RequestFinalizationResult = {
+    status: "completed";
+    output: string;
+} | {
+    status: "failed";
+};
+export declare function failRequest(params: {
+    events: EventSink;
+    error: string;
+    details?: Record<string, unknown>;
+}): void;
+export declare function finalizeRequest(params: {
+    rawOutput: string;
+    outputTextMode?: RequestOutputTextMode;
+    events: EventSink;
+    lifecycle: RequestLifecycle;
+    sessionStore: Pick<RequestSessionStore, "appendMessage">;
+    sessionId: string;
+    requestId: string;
+    agentMode: AgentMode;
+    thinkingTrace?: SessionThinkingTraceEntry[];
+    finalObservation?: RequestObservation;
+}): Promise<RequestFinalizationResult>;
+export {};