@xfey/tutti 0.1.10 → 0.1.12

package/dist/control-plane/context-sync.js

@@ -70,6 +70,7 @@ export function startContextSyncAnalysisProcedure(input) {
             const output = await runnerResolution.runner.runContextSync?.(workflowInput, {
                 workflow_ref: workflowRef,
                 activity_ref: context.activity_ref,
+                reportProgress: context.reportProgress,
             });
             if (output === undefined) {
                 return {

package/dist/control-plane/event-publishers.js

@@ -135,18 +135,27 @@ export function publishRunTransition(input) {
     }
 }
 export function publishProcedureTransition(input) {
-    const eventPayload = input.state.activity.status === "running"
-        ? undefined
-        : {
-            terminal: {
-                result_kind: input.state.activity.status === "finished"
-                    ? "finished"
-                    : input.state.activity.status === "needs_human"
-                        ? "needs_human"
-                        : "failed",
-                summary: input.state.activity.summary,
+    const eventPayload = input.state.transition_kind === "progress"
+        ? {
+            progress: {
+                message: input.state.progress?.summary ?? input.state.activity.summary,
+                ...(input.state.progress?.phase === undefined
+                    ? {}
+                    : { phase: input.state.progress.phase }),
             },
-        };
+        }
+        : input.state.activity.status === "running"
+            ? undefined
+            : {
+                terminal: {
+                    result_kind: input.state.activity.status === "finished"
+                        ? "finished"
+                        : input.state.activity.status === "needs_human"
+                            ? "needs_human"
+                            : "failed",
+                    summary: input.state.activity.summary,
+                },
+            };
     input.events.publish({
         event_type: "activity.event",
         payload: {
@@ -154,7 +163,7 @@ export function publishProcedureTransition(input) {
             event: {
                 event_ref: createEventRef(),
                 activity_ref: input.state.activity.activity_ref,
-                event_kind: activityEventKind(input.state.activity),
+                event_kind: activityEventKind(input.state.activity, input.state.transition_kind),
                 occurred_at: input.now().toISOString(),
                 summary: input.state.activity.summary,
                 ...(eventPayload === undefined ? {} : { payload: eventPayload }),

package/dist/control-plane/execution-status.js

@@ -31,6 +31,10 @@ export function readControlPlaneExecutionStatus(options) {
         else if (activeProcedureActivity !== undefined) {
             status.active_activity = activeProcedureActivity;
         }
+        const runtime = activeRunStatus.runtime ?? activeStatus.runtime;
+        if (runtime !== undefined) {
+            status.runtime = runtime;
+        }
         appendActiveActivities(status, activeActivities);
         const lastConclusion = activeRunStatus.last_conclusion ?? activeStatus.last_conclusion;
         if (lastConclusion !== undefined) {

package/dist/control-plane/project-context-bootstrap.d.ts

@@ -1,5 +1,6 @@
 import type { ActivityRef, WorkflowInvocationRef } from "@tutti/shared/ids";
 import type { ScratchpadProjection } from "@tutti/shared/schemas/api";
+import type { ProcedureProgressUpdate } from "../procedure-engine/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { InitializeProjectDocsResult, ProjectDocsInitializationContext, ProjectDocsInitializationDocument } from "../workspace-ops/index.js";
 import type { ControlPlaneLogger, Phase5ControlPlaneOptions } from "./types.js";
@@ -20,6 +21,7 @@ export declare function tryProjectContextBootstrapDocuments(input: {
     workflowRef: WorkflowInvocationRef;
     activityRef: ActivityRef;
     logger?: ControlPlaneLogger | undefined;
+    reportProgress?: (progress: ProcedureProgressUpdate) => void;
     now: () => Date;
 }): Promise<ProjectDocsInitializationDocument[] | undefined>;
 export declare function applyProjectDocsInitializationResult(input: {

package/dist/control-plane/project-context-bootstrap.js

@@ -65,6 +65,7 @@ export async function tryProjectContextBootstrapDocuments(input) {
         const output = await input.runner.runProjectContextBootstrap(workflowInput, {
             workflow_ref: input.workflowRef,
             activity_ref: input.activityRef,
+            ...(input.reportProgress === undefined ? {} : { reportProgress: input.reportProgress }),
         });
         input.logger?.info({
             workflow_ref: input.workflowRef,

package/dist/control-plane/reference-summary-refresh.js

@@ -81,6 +81,9 @@ async function runReferenceSummaryRefresh(options) {
             }, {
                 workflow_ref: options.workflowRef,
                 activity_ref: options.activityRef,
+                ...(options.reportProgress === undefined
+                    ? {}
+                    : { reportProgress: options.reportProgress }),
             });
             if (output === undefined) {
                 adapterUnavailableCount += 1;
@@ -308,6 +311,7 @@ export function startReferenceSummaryRefreshProcedure(input) {
             projectContext,
             events: input.events,
             logger: input.logger,
+            reportProgress: context.reportProgress,
             now: input.now,
         }),
     });

package/dist/control-plane/run-start.js

@@ -91,6 +91,7 @@ export function startControlPlaneRunForTask(input) {
                     on_stage: (progress) => context.reportProgress({
                         phase: progress.stage,
                         summary: runStageSummary(input.run, progress),
+                        ...(progress.runtime === undefined ? {} : { runtime: progress.runtime }),
                     }),
                 });
                 const resultRecord = recordRunPipelineResult({

package/dist/control-plane/task-compile-continuation.js

@@ -48,6 +48,7 @@ export function startControlPlaneTaskCompileContinuation(options) {
                 }, {
                     workflow_ref: workflowRef,
                     activity_ref: context.activity_ref,
+                    reportProgress: context.reportProgress,
                 });
                 const conclusion = applyTaskCompileProcedureOutput({
                     store: options.store,

package/dist/control-plane/task-compile-start.d.ts

@@ -1,6 +1,6 @@
 import { type ActivityRef, type WorkflowInvocationRef } from "@tutti/shared/ids";
 import type { SubmitWorklistDisposition, SubmitWorklistPayload, SubmitWorklistResult } from "@tutti/shared/schemas/api";
-import type { ProcedureEngine, ProcedureEngineState } from "../procedure-engine/index.js";
+import type { ProcedureEngine, ProcedureEngineState, ProcedureProgressUpdate } from "../procedure-engine/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { HostProjectStore } from "../store/index.js";
 import type { ControlPlaneCommandResult, ControlPlaneLogger, Phase5ControlPlaneOptions } from "./types.js";
@@ -25,6 +25,7 @@ export declare function runControlPlaneTaskCompileProcedure(options: {
     events: WorkspaceEventBus;
     now: () => Date;
     onTasksAdded: () => void;
+    reportProgress?: (progress: ProcedureProgressUpdate) => void;
 }): Promise<{
     kind: "needs_human";
     summary: string;

package/dist/control-plane/task-compile-start.js

@@ -88,6 +88,7 @@ function startControlPlaneTaskCompileActivity(options) {
             events: options.events,
             workflowRef,
             activityRef: context.activity_ref,
+            reportProgress: context.reportProgress,
             now: options.now,
             onTasksAdded: options.onTasksAdded,
         }),
@@ -212,6 +213,7 @@ function startProjectContextBootstrapActivity(options) {
                 workflowRef,
                 activityRef: context.activity_ref,
                 logger: options.logger,
+                reportProgress: context.reportProgress,
                 now: options.now,
             });
             const initialized = initializeProjectDocs({
@@ -266,6 +268,9 @@ export async function runControlPlaneTaskCompileProcedure(options) {
     }, {
         workflow_ref: options.workflowRef,
         activity_ref: options.activityRef,
+        ...(options.reportProgress === undefined
+            ? {}
+            : { reportProgress: options.reportProgress }),
     });
     return applyTaskCompileProcedureOutput({
         store: options.store,

package/dist/control-plane/types.d.ts

@@ -1,7 +1,7 @@
 import type { AccountAvatarProjection, RunLineage } from "@tutti/shared/domain";
 import type { RuntimeLogger } from "@tutti/shared/utils";
 import type { ActivityRef, ClarificationRoundRef, TaskId, TaskModuleId } from "@tutti/shared/ids";
-import type { ActiveApprovalProjection, ClarificationRequestPayload, MessageProjection, RecoverySummaryProjection, TaskDetailProjection, TaskProjection } from "@tutti/shared/schemas/api";
+import type { ActiveApprovalProjection, ClarificationRequestPayload, ExecutionRuntimeSnapshot, MessageProjection, RecoverySummaryProjection, TaskDetailProjection, TaskProjection } from "@tutti/shared/schemas/api";
 import type { HostProjectStore } from "../store/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { CleanupStaleRunWorkspacesResult } from "../workspace-ops/index.js";
@@ -102,6 +102,7 @@ export type RunPipelineInput = {
 export type RunPipelineStageProgress = {
     stage: string;
     summary: string;
+    runtime?: ExecutionRuntimeSnapshot;
 };
 export type RunPipelineTimelineEvent = {
     event_kind: "promotion_reconcile";

package/dist/control-plane/workflows/openai.js

@@ -44,6 +44,21 @@ function readOnlyAppServerOptions(options, prompt, outputSchema, skillSelectionN
             : { agentContext: options.readOnlyAppServer.agentContext }),
     };
 }
+function readOnlyRuntimeTelemetry(context, stageId) {
+    if (context?.reportProgress === undefined) {
+        return {};
+    }
+    return {
+        runtimeTelemetry: {
+            activityRef: context.activity_ref,
+            stageId,
+            onSnapshot: (snapshot) => context.reportProgress?.({
+                phase: stageId,
+                runtime: snapshot,
+            }),
+        },
+    };
+}
 function referenceSummarySourcePath(options, input) {
     if (options.readOnlyAppServer === undefined) {
         throw new Error("Codex app-server read-only Procedure adapter is not configured");
@@ -266,6 +281,7 @@ export function createOpenAiProcedureWorkflowRunner(options) {
             });
             const result = await runCodexAppServerReadOnlyProcedure({
                 ...readOnlyAppServerOptions(options, instructions, TASK_COMPILE_OUTPUT_SCHEMA, "task_compile"),
+                ...readOnlyRuntimeTelemetry(context, "task_compile"),
                 validateOutput: isTaskCompileStructuredOutput,
                 networkAccess: false,
                 webSearchMode: "disabled",
@@ -314,6 +330,7 @@ export function createOpenAiProcedureWorkflowRunner(options) {
             });
             const result = await runCodexAppServerReadOnlyProcedure({
                 ...readOnlyAppServerOptions(options, instructions, PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA, "project_context_bootstrap"),
+                ...readOnlyRuntimeTelemetry(context, "project_context_bootstrap"),
                 validateOutput: isProjectContextBootstrapWorkflowOutput,
             });
             recordUsage(options, "project_context_bootstrap", result, {
@@ -329,6 +346,7 @@ export function createOpenAiProcedureWorkflowRunner(options) {
             });
             const result = await runCodexAppServerReadOnlyProcedure({
                 ...readOnlyAppServerOptions(options, instructions, CONTEXT_SYNC_OUTPUT_SCHEMA, "context_sync"),
+                ...readOnlyRuntimeTelemetry(context, "context_sync"),
                 validateOutput: isContextSyncWorkflowOutput,
             });
             recordUsage(options, "context_sync", result, {
@@ -350,6 +368,7 @@ export function createOpenAiProcedureWorkflowRunner(options) {
             try {
                 const result = await runCodexAppServerReadOnlyProcedure({
                     ...readOnlyAppServerOptions(options, instructions, REFERENCE_FILE_SUMMARY_OUTPUT_SCHEMA, "reference_summary_refresh"),
+                    ...readOnlyRuntimeTelemetry(context, "reference_summary_refresh"),
                     appServerCwd: workspace.cwd,
                     validateOutput: isReferenceFileSummaryStructuredOutput,
                     readablePaths: [workspace.cwd],

package/dist/control-plane/workflows/types.d.ts

@@ -1,4 +1,4 @@
-import type { MessageProjection, RunResultProjection, ScratchpadProjection, TaskDetailProjection, WorklistProjection } from "@tutti/shared/schemas/api";
+import type { ExecutionRuntimeSnapshot, MessageProjection, RunResultProjection, ScratchpadProjection, TaskDetailProjection, WorklistProjection } from "@tutti/shared/schemas/api";
 import type { ClarificationRequestPayload, TaskContractProjection } from "@tutti/shared/schemas/api";
 import type { ProjectDocKey } from "@tutti/shared/schemas/api";
 import type { ActivityRef, ClarificationRoundRef, ClarificationThreadRef, MessageId, TaskId, TaskModuleId, WorkflowInvocationRef } from "@tutti/shared/ids";
@@ -29,6 +29,11 @@ export type ScratchpadRefreshWorkflowContext = {
 export type ProcedureWorkflowRunContext = {
     workflow_ref: WorkflowInvocationRef;
     activity_ref: ActivityRef;
+    reportProgress?: (progress: {
+        summary?: string;
+        phase?: string;
+        runtime?: ExecutionRuntimeSnapshot;
+    }) => void;
 };
 export type ScratchpadRefreshWorkflowOutput = {
     decision: "ready";

package/dist/procedure-engine/index.d.ts

@@ -1,6 +1,6 @@
 import { type ActivityRef, type WorkflowInvocationRef } from "@tutti/shared/ids";
 import type { ResultAnchor, WorkflowKind } from "@tutti/shared/domain";
-import type { ActivityProjection, ExecutionStatusProjection, ProcedureLane } from "@tutti/shared/schemas/api";
+import type { ActivityProjection, ExecutionRuntimeSnapshot, ExecutionStatusProjection, ProcedureLane } from "@tutti/shared/schemas/api";
 export type ProcedureTerminalConclusion = {
     kind: "completed" | "failed" | "needs_human";
     summary: string;
@@ -11,6 +11,12 @@ export type ProcedureExecutionContext = {
     workflow_ref: WorkflowInvocationRef;
     workflow_kind: WorkflowKind;
     lane: ProcedureLane;
+    reportProgress: (progress: ProcedureProgressUpdate) => void;
+};
+export type ProcedureProgressUpdate = {
+    summary?: string;
+    phase?: string;
+    runtime?: ExecutionRuntimeSnapshot;
 };
 export type StartProcedureOptions = {
     workflow_ref: WorkflowInvocationRef;
@@ -36,6 +42,8 @@ export type StartProcedureResult = {
 export type ProcedureEngineState = {
     activity: ActivityProjection;
     execution_status: ExecutionStatusProjection;
+    transition_kind: "started" | "progress" | "terminal";
+    progress?: ProcedureProgressUpdate;
 };
 export declare class ProcedureEngine {
     private readonly activeByLane;
@@ -49,6 +57,7 @@ export declare class ProcedureEngine {
     getExecutionStatus(): ExecutionStatusProjection;
     waitForIdle(): Promise<void>;
     private stateForActivity;
+    private updateActiveProgress;
     private finishActive;
     private primaryActiveProcedure;
     private orderedActiveProcedures;

package/dist/procedure-engine/index.js

@@ -39,6 +39,7 @@ export class ProcedureEngine {
             workflow_ref: options.workflow_ref,
             workflow_kind: options.workflow_kind,
             lane,
+            reportProgress: (progress) => this.updateActiveProgress(activityRef, lane, progress, options.onTransition),
         };
         const run = async () => {
             try {
@@ -60,7 +61,7 @@ export class ProcedureEngine {
         };
         const promise = Promise.resolve().then(run);
         this.activeByLane.set(lane, { activity, lane, promise });
-        options.onTransition?.(this.stateForActivity(activity));
+        options.onTransition?.(this.stateForActivity(activity, "started"));
         return {
             kind: "accepted",
             activity,
@@ -73,13 +74,17 @@ export class ProcedureEngine {
         const active = this.primaryActiveProcedure();
         if (active !== null) {
             const activeActivities = this.orderedActiveProcedures().map((entry) => executionActivityFromProcedure(entry.activity));
-            return {
+            const status = {
                 status: "running",
                 summary: active.activity.summary,
                 active_activity: executionActivityFromProcedure(active.activity),
                 active_activities: activeActivities,
                 updated_at: this.now().toISOString(),
             };
+            if (active.runtime !== undefined) {
+                status.runtime = active.runtime;
+            }
+            return status;
         }
         const idle = {
             status: "idle",
@@ -96,11 +101,35 @@ export class ProcedureEngine {
             await Promise.all(this.orderedActiveProcedures().map((active) => active.promise));
         }
     }
-    stateForActivity(activity) {
-        return {
+    stateForActivity(activity, transitionKind, progress) {
+        const state = {
             activity,
             execution_status: this.getExecutionStatus(),
+            transition_kind: transitionKind,
         };
+        if (progress !== undefined) {
+            state.progress = progress;
+        }
+        return state;
+    }
+    updateActiveProgress(activityRef, lane, progress, onTransition) {
+        const active = this.activeByLane.get(lane);
+        if (active === undefined || active.activity.activity_ref !== activityRef) {
+            return;
+        }
+        if (progress.summary !== undefined) {
+            active.activity.summary = progress.summary;
+        }
+        if (progress.runtime !== undefined) {
+            active.runtime = progress.runtime;
+        }
+        else if (progress.phase !== undefined && active.runtime !== undefined) {
+            active.runtime = {
+                ...active.runtime,
+                stage_id: progress.phase,
+            };
+        }
+        onTransition?.(this.stateForActivity(active.activity, "progress", progress));
     }
     finishActive(activityRef, lane, conclusion, onTransition) {
         const active = this.activeByLane.get(lane);
@@ -132,6 +161,7 @@ export class ProcedureEngine {
         onTransition?.({
             activity: active.activity,
             execution_status: this.getExecutionStatus(),
+            transition_kind: "terminal",
         });
     }
     primaryActiveProcedure() {

package/dist/providers/openai/app-server/json-rpc.d.ts

@@ -23,12 +23,17 @@ export type CodexAppServerJsonRpcError = {
     message: string;
     data?: unknown;
 };
+export type CodexAppServerJsonRpcClientOptions = {
+    onNotification?: (notification: CodexAppServerJsonRpcNotification) => void;
+    onServerRequest?: (request: CodexAppServerJsonRpcServerRequest) => void;
+};
 export declare class CodexAppServerProtocolError extends Error {
     readonly code: string;
     constructor(message: string, code: string);
 }
 export declare class CodexAppServerJsonRpcClient {
     private readonly child;
+    private readonly options;
     private readonly decoder;
     private readonly pendingRequests;
     private readonly notificationWaiters;
@@ -42,7 +47,7 @@ export declare class CodexAppServerJsonRpcClient {
     private readonly notificationList;
     private readonly serverRequestList;
     private readonly unresolvedServerRequestIds;
-    constructor(child: ChildProcessWithoutNullStreams);
+    constructor(child: ChildProcessWithoutNullStreams, options?: CodexAppServerJsonRpcClientOptions);
     get notifications(): readonly CodexAppServerJsonRpcNotification[];
     get serverRequests(): readonly CodexAppServerJsonRpcServerRequest[];
     get stderr(): string;

package/dist/providers/openai/app-server/json-rpc.js

@@ -23,6 +23,7 @@ function normalizeProtocolError(method, error) {
 }
 export class CodexAppServerJsonRpcClient {
     child;
+    options;
     decoder = new StringDecoder("utf8");
     pendingRequests = new Map();
     notificationWaiters = new Set();
@@ -36,8 +37,9 @@ export class CodexAppServerJsonRpcClient {
     notificationList = [];
     serverRequestList = [];
     unresolvedServerRequestIds = new Set();
-    constructor(child) {
+    constructor(child, options = {}) {
         this.child = child;
+        this.options = options;
         child.stdout.on("data", (chunk) => this.handleStdout(chunk));
         child.stderr.on("data", (chunk) => {
             this.recordActivity();
@@ -272,6 +274,12 @@ export class CodexAppServerJsonRpcClient {
     recordNotification(notification) {
         this.recordActivity();
         this.notificationList.push(notification);
+        try {
+            this.options.onNotification?.(notification);
+        }
+        catch {
+            // Runtime observers must not affect JSON-RPC delivery.
+        }
         for (const waiter of Array.from(this.notificationWaiters)) {
             if (!waiter.predicate(notification)) {
                 continue;
@@ -285,6 +293,12 @@ export class CodexAppServerJsonRpcClient {
         this.recordActivity();
         this.serverRequestList.push(request);
         this.unresolvedServerRequestIds.add(request.id);
+        try {
+            this.options.onServerRequest?.(request);
+        }
+        catch {
+            // Runtime observers must not affect interactive request handling.
+        }
         for (const waiter of Array.from(this.serverRequestWaiters)) {
             clearTimeout(waiter.timer);
             this.serverRequestWaiters.delete(waiter);

package/dist/providers/openai/app-server/read-only-procedure.d.ts

@@ -1,3 +1,4 @@
+import { type CodexAppServerRuntimeTelemetryOptions } from "./runtime-telemetry.js";
 import { type CodexAppServerAgentContextRuntime, type CodexAppServerSkillSelectionName } from "./skills.js";
 import { type OpenAiTokenUsage } from "../token-usage.js";
 export type CodexAppServerWebSearchMode = "disabled" | "cached" | "live";
@@ -22,6 +23,7 @@ export type CodexAppServerReadOnlyProcedureInput<TOutput> = {
     requestTimeoutMs?: number;
     turnTimeoutMs?: number;
     baseEnv?: NodeJS.ProcessEnv;
+    runtimeTelemetry?: CodexAppServerRuntimeTelemetryOptions;
 };
 export type CodexAppServerReadOnlyProcedureResult<TOutput> = {
     output: TOutput;

package/dist/providers/openai/app-server/read-only-procedure.js

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { buildCodexAppServerProcessPlan } from "../codex-app-server.js";
 import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
 import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./json-rpc.js";
+import { createCodexAppServerRuntimeObserver, } from "./runtime-telemetry.js";
 import { createReadOnlySandboxPolicy } from "./sandbox-policy.js";
 import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
 import { buildCodexAppServerTurnInput, resolveCodexAppServerContextRuntimeHint, resolveCodexAppServerSkillInputs, CodexAppServerSkillSelectionError, } from "./skills.js";
@@ -125,7 +126,17 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
         env: createCodexSpawnEnv(codexHome, options.baseEnv ?? process.env),
         stdio: "pipe",
     });
-    const client = new CodexAppServerJsonRpcClient(child);
+    const runtimeObserver = options.runtimeTelemetry === undefined
+        ? undefined
+        : createCodexAppServerRuntimeObserver(options.runtimeTelemetry);
+    const client = new CodexAppServerJsonRpcClient(child, {
+        ...(runtimeObserver === undefined
+            ? {}
+            : {
+                onNotification: runtimeObserver.notification,
+                onServerRequest: runtimeObserver.serverRequest,
+            }),
+    });
     const sensitiveValues = [
         options.apiKey,
         tempRoot,
@@ -284,6 +295,7 @@ export async function runCodexAppServerReadOnlyProcedure(options) {
         throw new CodexAppServerReadOnlyProcedureError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues));
     }
     finally {
+        runtimeObserver?.flush();
         client.dispose();
         rmSync(tempRoot, { recursive: true, force: true });
     }

package/dist/providers/openai/app-server/runtime-telemetry.d.ts

@@ -0,0 +1,18 @@
+import type { ActivityRef } from "@tutti/shared/ids";
+import type { ExecutionRuntimeSnapshot } from "@tutti/shared/schemas/api";
+import type { CodexAppServerJsonRpcNotification, CodexAppServerJsonRpcServerRequest } from "./json-rpc.js";
+export type CodexAppServerRuntimeTelemetryOptions = {
+    activityRef: ActivityRef;
+    stageId?: string;
+    startedAt?: string;
+    throttleMs?: number;
+    now?: () => Date;
+    onSnapshot?: (snapshot: ExecutionRuntimeSnapshot) => void;
+};
+export type CodexAppServerRuntimeObserver = {
+    notification: (notification: CodexAppServerJsonRpcNotification) => void;
+    serverRequest: (request: CodexAppServerJsonRpcServerRequest) => void;
+    flush: () => void;
+};
+export declare function createCodexAppServerRuntimeObserver(options: CodexAppServerRuntimeTelemetryOptions): CodexAppServerRuntimeObserver;
+//# sourceMappingURL=runtime-telemetry.d.ts.map

package/dist/providers/openai/app-server/runtime-telemetry.js

@@ -0,0 +1,130 @@
+import { extractCodexAppServerTokenUsage } from "../token-usage.js";
+const DEFAULT_THROTTLE_MS = 5_000;
+function searchText(value) {
+    if (typeof value === "string") {
+        return value.toLocaleLowerCase();
+    }
+    if (typeof value !== "object" || value === null) {
+        return "";
+    }
+    const record = value;
+    const tokens = ["type", "kind", "name", "status", "method", "state"]
+        .map((key) => record[key])
+        .filter((entry) => typeof entry === "string");
+    return tokens.join(" ").toLocaleLowerCase();
+}
+function actionFromNotification(notification) {
+    const method = notification.method;
+    const paramsText = searchText(notification.params);
+    const combined = `${method} ${paramsText}`.toLocaleLowerCase();
+    if (combined.includes("commandexecution") || combined.includes("command_execution")) {
+        return "running_command";
+    }
+    if (combined.includes("filechange") || combined.includes("file_change")) {
+        return "editing_files";
+    }
+    if (combined.includes("plan")) {
+        return "planning";
+    }
+    if (combined.includes("mcptoolcall") ||
+        combined.includes("mcp_tool_call") ||
+        combined.includes("dynamictoolcall") ||
+        combined.includes("dynamic_tool_call") ||
+        combined.includes("websearch") ||
+        combined.includes("web_search")) {
+        return "using_tool";
+    }
+    if (combined.includes("reasoning")) {
+        return "reading_context";
+    }
+    if (method === "item/agentMessage/delta" || method === "item/completed") {
+        return "finalizing";
+    }
+    return undefined;
+}
+function runtimeTokenUsage(usage) {
+    return {
+        input_tokens: usage.input_tokens,
+        cached_input_tokens: usage.cached_input_tokens,
+        output_tokens: usage.output_tokens,
+        reasoning_output_tokens: usage.reasoning_output_tokens,
+        total_tokens: usage.total_tokens,
+    };
+}
+export function createCodexAppServerRuntimeObserver(options) {
+    let latest;
+    let timer;
+    let lastEmittedAt = 0;
+    const throttleMs = options.throttleMs ?? DEFAULT_THROTTLE_MS;
+    const now = options.now ?? (() => new Date());
+    const emit = () => {
+        if (latest === undefined || options.onSnapshot === undefined) {
+            return;
+        }
+        lastEmittedAt = Date.now();
+        options.onSnapshot(latest);
+    };
+    const scheduleEmit = () => {
+        if (options.onSnapshot === undefined) {
+            return;
+        }
+        const elapsed = Date.now() - lastEmittedAt;
+        if (elapsed >= throttleMs) {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+            emit();
+            return;
+        }
+        if (timer !== undefined) {
+            return;
+        }
+        timer = setTimeout(() => {
+            timer = undefined;
+            emit();
+        }, Math.max(1, throttleMs - elapsed));
+    };
+    const update = (patch) => {
+        if (patch.currentAction === undefined && patch.tokenUsage === undefined) {
+            return;
+        }
+        const updatedAt = now().toISOString();
+        latest = {
+            activity_ref: options.activityRef,
+            ...(options.stageId === undefined ? {} : { stage_id: options.stageId }),
+            ...(options.startedAt === undefined ? {} : { started_at: options.startedAt }),
+            ...(latest?.token_usage === undefined ? {} : { token_usage: latest.token_usage }),
+            ...(latest?.current_action === undefined ? {} : { current_action: latest.current_action }),
+            updated_at: updatedAt,
+        };
+        if (patch.tokenUsage !== undefined) {
+            latest.token_usage = runtimeTokenUsage(patch.tokenUsage);
+        }
+        if (patch.currentAction !== undefined) {
+            latest.current_action = patch.currentAction;
+        }
+        scheduleEmit();
+    };
+    return {
+        notification: (notification) => {
+            const tokenUsage = extractCodexAppServerTokenUsage([notification]);
+            const currentAction = actionFromNotification(notification);
+            update({
+                ...(tokenUsage === undefined ? {} : { tokenUsage }),
+                ...(currentAction === undefined ? {} : { currentAction }),
+            });
+        },
+        serverRequest: () => {
+            update({ currentAction: "waiting_for_approval" });
+        },
+        flush: () => {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+            emit();
+        },
+    };
+}
+//# sourceMappingURL=runtime-telemetry.js.map