@demicodes/agent 0.1.0

package/dist/json-codec-BFLXlg3K.mjs

@@ -0,0 +1,70 @@
+//#region src/json-codec.ts
+const BINARY_MARKER = "__demiUint8Array";
+const BIGINT_MARKER = "__demiBigInt";
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function stringifyAgentJson(value) {
+	return JSON.stringify(value, (_key, nested) => {
+		if (nested instanceof Uint8Array) return {
+			[BINARY_MARKER]: true,
+			base64: bytesToBase64(nested)
+		};
+		if (typeof nested === "bigint") return {
+			[BIGINT_MARKER]: true,
+			value: nested.toString()
+		};
+		return nested;
+	});
+}
+function parseAgentJson(text) {
+	return JSON.parse(text, (_key, nested) => {
+		if (isEncodedUint8Array(nested)) return base64ToBytes(nested.base64);
+		if (isEncodedBigInt(nested)) return BigInt(nested.value);
+		return nested;
+	});
+}
+function isEncodedUint8Array(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && value[BINARY_MARKER] === true && typeof value.base64 === "string";
+}
+function isEncodedBigInt(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && value[BIGINT_MARKER] === true && typeof value.value === "string";
+}
+function bytesToBase64(bytes) {
+	let output = "";
+	for (let index = 0; index < bytes.byteLength; index += 3) {
+		const first = bytes[index];
+		const second = bytes[index + 1];
+		const third = bytes[index + 2];
+		output += BASE64_ALPHABET[first >> 2];
+		output += BASE64_ALPHABET[(first & 3) << 4 | (second ?? 0) >> 4];
+		output += second === void 0 ? "=" : BASE64_ALPHABET[(second & 15) << 2 | (third ?? 0) >> 6];
+		output += third === void 0 ? "=" : BASE64_ALPHABET[third & 63];
+	}
+	return output;
+}
+function base64ToBytes(base64) {
+	const clean = base64.replace(/\s+/g, "");
+	if (clean.length === 0) return /* @__PURE__ */ new Uint8Array();
+	if (clean.length % 4 !== 0) throw new Error("Invalid base64 payload length");
+	const padding = clean.endsWith("==") ? 2 : clean.endsWith("=") ? 1 : 0;
+	const bytes = new Uint8Array(clean.length / 4 * 3 - padding);
+	let offset = 0;
+	for (let index = 0; index < clean.length; index += 4) {
+		const first = base64Value(clean[index]);
+		const second = base64Value(clean[index + 1]);
+		const third = clean[index + 2] === "=" ? 0 : base64Value(clean[index + 2]);
+		const fourth = clean[index + 3] === "=" ? 0 : base64Value(clean[index + 3]);
+		const triple = first << 18 | second << 12 | third << 6 | fourth;
+		if (offset < bytes.byteLength) bytes[offset++] = triple >> 16 & 255;
+		if (offset < bytes.byteLength) bytes[offset++] = triple >> 8 & 255;
+		if (offset < bytes.byteLength) bytes[offset++] = triple & 255;
+	}
+	return bytes;
+}
+function base64Value(char) {
+	if (!char || char === "=") throw new Error("Invalid base64 payload");
+	const value = BASE64_ALPHABET.indexOf(char);
+	if (value === -1) throw new Error("Invalid base64 payload");
+	return value;
+}
+//#endregion
+export { stringifyAgentJson as n, parseAgentJson as t };

package/dist/stdio-transport.d.mts

@@ -0,0 +1,8 @@
+import { n as AgentServerTransport, t as AgentClientTransport } from "./transport-BkAbPvRc.mjs";
+import { Readable, Writable } from "node:stream";
+
+//#region src/stdio-transport.d.ts
+declare function createStdioClientTransport(readable: Readable, writable: Writable): AgentClientTransport;
+declare function createStdioServerTransport(readable: Readable, writable: Writable): AgentServerTransport;
+//#endregion
+export { createStdioClientTransport, createStdioServerTransport };

package/dist/stdio-transport.mjs

@@ -0,0 +1,45 @@
+import { n as stringifyAgentJson, t as parseAgentJson } from "./json-codec-BFLXlg3K.mjs";
+import { createInterface } from "node:readline";
+//#region src/stdio-transport.ts
+function createStdioClientTransport(readable, writable) {
+	return new JsonLineTransport(readable, writable);
+}
+function createStdioServerTransport(readable, writable) {
+	return new JsonLineTransport(readable, writable);
+}
+var JsonLineTransport = class {
+	readable;
+	writable;
+	handlers = /* @__PURE__ */ new Set();
+	readline;
+	closed = false;
+	constructor(readable, writable) {
+		this.readable = readable;
+		this.writable = writable;
+		this.readline = createInterface({ input: readable });
+		this.readline.on("line", (line) => {
+			if (this.closed || line.trim() === "") return;
+			const frame = parseAgentJson(line);
+			for (const handler of this.handlers) handler(frame);
+		});
+	}
+	send(frame) {
+		if (this.closed) throw new Error("Agent transport is closed");
+		this.writable.write(`${stringifyAgentJson(frame)}\n`);
+	}
+	onFrame(handler) {
+		this.handlers.add(handler);
+		return () => {
+			this.handlers.delete(handler);
+		};
+	}
+	close() {
+		this.closed = true;
+		this.handlers.clear();
+		this.readline.close();
+		this.readable.destroy();
+		this.writable.end();
+	}
+};
+//#endregion
+export { createStdioClientTransport, createStdioServerTransport };

package/dist/transport-BkAbPvRc.d.mts

@@ -0,0 +1,533 @@
+import { BashAuditEvent, CommandSpec, Host, ShellCommandSnapshot } from "@demicodes/shell";
+import { AgentProvider, InferenceItem, ProviderEvent, ProviderSelection, ToolDefinition } from "@demicodes/provider";
+import { Block, ModelSelection, QueuedMessage, SessionPhase, ToolResultContentBlock, Transcript, UserContentBlock } from "@demicodes/core";
+
+//#region src/retry-policy.d.ts
+/**
+ * Retry policy for provider requests, applied by the agent runtime (turn loop
+ * and compaction) — providers stay single-shot and only classify error codes.
+ * A request is retried only while it has produced no transcript content, so a
+ * retry can never duplicate partially streamed output.
+ */
+interface TurnRetryPolicy {
+  /** Total attempts including the first (default 4 = 1 original + 3 retries). */
+  maxAttempts: number;
+  /** Base for exponential backoff with full jitter (default 1000ms). */
+  baseDelayMs: number;
+  /** Backoff ceiling (default 30000ms). */
+  maxDelayMs: number;
+  /** Provider error codes that are retried (default rate_limit, overloaded). */
+  retryableCodes: string[];
+}
+declare const DEFAULT_TURN_RETRY_POLICY: TurnRetryPolicy;
+declare function resolveRetryPolicy(overrides: Partial<TurnRetryPolicy> | undefined): TurnRetryPolicy;
+declare function isRetryableCode(policy: TurnRetryPolicy, code: string | null): boolean;
+/**
+ * Delay before retry `attempt` (1-based): a provider-supplied Retry-After wins,
+ * otherwise exponential backoff with full jitter, capped at `maxDelayMs`.
+ */
+declare function retryDelayMs(policy: TurnRetryPolicy, attempt: number, retryAfterMs: number | null): number;
+//#endregion
+//#region src/transcript.d.ts
+interface TranscriptOptions {
+  idFactory?: () => string;
+  now?: () => string;
+  /**
+   * Per-text-block bounds applied when replaying to the model (head+tail with
+   * an elision marker). Defaults to 8000/8000 characters.
+   */
+  replayTextBounds?: {
+    headChars: number;
+    tailChars: number;
+  };
+}
+interface CompactionWindow {
+  startIndex: number;
+  cutPoint: number;
+}
+interface DrainedTranscriptPatches {
+  revision: number;
+  patches: TranscriptPatch[];
+}
+declare class Transcript$1 implements Transcript {
+  readonly blocks: Block[];
+  private readonly idFactory;
+  private readonly now;
+  private journal;
+  private revisionCounter;
+  private readonly replayHeadChars;
+  private readonly replayTailChars;
+  constructor(blocks?: Block[], options?: TranscriptOptions);
+  snapshot(): Transcript;
+  /** Monotonic revision, advanced once per drained patch batch. */
+  get revision(): number;
+  /**
+   * Drains the patches recorded since the last drain, advancing the revision.
+   * Returns null when nothing changed.
+   */
+  takePatches(): DrainedTranscriptPatches | null;
+  private record;
+  private recordAdd;
+  private recordBlockReplace;
+  private recordReplaceAll;
+  pushUserTurn(turnId: string, model: ModelSelection, content: UserContentBlock[], preamble?: string | null, hidden?: boolean): Block;
+  pushResumeTurn(turnId: string, model: ModelSelection): Block;
+  pushSteer(turnId: string, model: ModelSelection, content: UserContentBlock[], id?: string, hidden?: boolean): Block;
+  pushAbort(model: ModelSelection, isResumed?: boolean): Block;
+  markLatestAbortResumed(): boolean;
+  /**
+   * Rewrites the transcript for a retry: drops everything after the last user
+   * turn except that turn's steers (which are replayed to the new attempt).
+   * Returns the user block, or null when there is no user turn to retry.
+   */
+  rewindToLastUserTurn(): Extract<Block, {
+    type: 'user';
+  }> | null;
+  applyProviderEvent(model: ModelSelection, event: ProviderEvent): Block | null;
+  completeToolCall(toolUseId: string, output: ToolResultContentBlock[], isError?: boolean, metadata?: unknown | null): Block | null;
+  findPendingToolUseId(): string | null;
+  pendingToolCalls(): Extract<Block, {
+    type: 'tool_call';
+  }>[];
+  removeDanglingToolCalls(): Block[];
+  findLastCompactionIndex(): number | null;
+  findCompactionCutPoint(keepRecentTokens: number): number | null;
+  findCompactionWindow(keepRecentTokens: number): CompactionWindow | null;
+  insertCompactionBoundary(index: number, model: ModelSelection, summary: string, summaryTokens: number): Block;
+  appendCompactionMarker(model: ModelSelection, boundaryId: string, compactedTokens: number): Block;
+  appendExtensionStateSnapshot(extensionName: string, state: unknown): Block;
+  latestExtensionStateSnapshot(extensionName?: string): Extract<Block, {
+    type: 'extension_state_snapshot';
+  }> | null;
+  replayableBlocks(): Block[];
+  collectInferenceItems(): InferenceItem[];
+  /**
+   * Estimates the next request's context size. When a provider-reported usage
+   * exists after the last compaction (the most recent real measurement of this
+   * history), it anchors the estimate and only blocks streamed after it are
+   * char-estimated; otherwise the whole replay window is estimated at ~4
+   * chars/token with fixed weights for images and documents.
+   */
+  estimateContextTokens(): number;
+  /**
+   * The latest response block's usage, valid only when no compaction happened
+   * after it (compaction shrinks the history the usage was measured against).
+   */
+  private usageAnchor;
+  private appendText;
+  private appendThinking;
+  private setLatestThinkingSignature;
+  private appendBlock;
+}
+/** Char-based per-block estimate, exported for compaction metrics. */
+declare function estimateTranscriptBlockTokens(block: Block): number;
+//#endregion
+//#region src/types.d.ts
+interface AgentPromptContext<State> {
+  agentSessionId: string;
+  state: State;
+  cwd: string;
+  transcript: Transcript$1;
+}
+interface AgentSystemPromptContext<State> extends AgentPromptContext<State> {
+  /**
+   * Rendered help for every registered command (summary, subcommands, parameters,
+   * stdin fields, examples), produced by the server from the session's actual
+   * CommandRegistry. Harnesses embed it wherever their system prompt wants the
+   * command reference; empty string when no commands are registered.
+   */
+  commandsPrompt: string;
+}
+interface AgentToolContext<State> {
+  agentSessionId: string;
+  state: State;
+  cwd: string;
+}
+interface AgentDisposeContext<State> {
+  agentSessionId: string;
+  state: State;
+  cwd: string;
+  transcript: Transcript$1;
+}
+interface AgentReferenceResolveContext<State> {
+  agentSessionId: string;
+  state: State;
+  cwd: string;
+  transcript: Transcript$1;
+  signal: AbortSignal;
+}
+interface AgentHarnessContext<State> {
+  state: State;
+  cwd: string;
+}
+interface AgentHarness<State = unknown> {
+  name: string;
+  initialState(): State;
+  host(ctx: AgentHarnessContext<State>): Host;
+  commands?(ctx: AgentHarnessContext<State>): CommandSpec[];
+  systemPrompt(ctx: AgentSystemPromptContext<State>): string;
+  preamble?(ctx: AgentPromptContext<State>): string | null;
+  resolveReferences?(ctx: AgentReferenceResolveContext<State>, content: UserContentBlock[]): Promise<UserContentBlock[]> | UserContentBlock[];
+  lifecycle?(event: AgentLifecycleEvent<State>): Promise<void> | void;
+  dispose?(ctx: AgentDisposeContext<State>): Promise<void> | void;
+}
+interface AgentToolInvokeContext<State> {
+  agentSessionId: string;
+  state: State;
+  cwd: string;
+  model: ModelSelection;
+  toolCallId: string;
+  signal: AbortSignal;
+  emitProgress(progress: unknown): void;
+}
+interface AgentToolInvokeResult {
+  output: ToolResultContentBlock[];
+  isError?: boolean;
+  metadata?: unknown | null;
+  continuation?: ToolContinuation;
+  stopAfterToolResult?: boolean;
+}
+interface ToolContinuation {
+  toolCallId: string;
+  shellId: string;
+  commandId: string;
+  status: 'running';
+}
+type AbortTarget = 'active_provider_stream' | 'active_tool' | 'active_compaction' | 'active_turn' | 'queued_action' | 'queued_message' | 'pending_yield_wakeup';
+interface AbortResult {
+  aborted: boolean;
+  target: AbortTarget | null;
+  canAbortAgain: boolean;
+}
+interface AgentTool<State = unknown> extends ToolDefinition {
+  invoke(ctx: AgentToolInvokeContext<State>, input: unknown): Promise<AgentToolInvokeResult> | AgentToolInvokeResult;
+}
+type AgentLifecycleEvent<State> = {
+  type: 'before_round_start';
+  agentSessionId: string;
+  state: State;
+  transcript: Transcript$1;
+  content: UserContentBlock[];
+} | {
+  type: 'after_tool_call';
+  agentSessionId: string;
+  state: State;
+  transcript: Transcript$1;
+  toolCallId: string;
+  toolName: string;
+  result: AgentToolInvokeResult;
+} | {
+  type: 'after_transcript_rewrite';
+  agentSessionId: string;
+  state: State;
+  transcript: Transcript$1;
+  reason: 'retry';
+};
+interface AgentHarnessRuntime<State> {
+  harnessName: string;
+  initialState(): State;
+  systemPrompt(ctx: AgentPromptContext<State>): string;
+  preamble?(ctx: AgentPromptContext<State>): string | null;
+  resolveReferences?(ctx: AgentReferenceResolveContext<State>, content: UserContentBlock[]): Promise<UserContentBlock[]> | UserContentBlock[];
+  tools(ctx: AgentToolContext<State>): AgentTool<State>[];
+  lifecycle?(event: AgentLifecycleEvent<State>): Promise<void> | void;
+  dispose?(ctx: AgentDisposeContext<State>): Promise<void> | void;
+}
+interface AgentSessionParams<State> {
+  provider: AgentProvider;
+  model: ModelSelection;
+  cwd: string;
+  runtime: AgentHarnessRuntime<State>;
+  transcript?: Transcript | Transcript$1;
+  state?: State;
+}
+interface AgentSessionSnapshot<State> {
+  transcript: Transcript;
+  state: State;
+  phase: SessionPhase;
+  queue: QueuedMessage[];
+  cwd: string;
+  model: ModelSelection;
+  harnessName: string;
+}
+interface AgentSessionStore<State = unknown> {
+  saveSnapshot(snapshot: AgentSessionSnapshot<State>): Promise<void> | void;
+  /** Load a previously saved snapshot for this session, or null if none exists. */
+  loadSnapshot(): Promise<AgentSessionSnapshot<State> | null>;
+}
+interface AgentSessionRestoreParams<State> {
+  provider: AgentProvider;
+  runtime: AgentHarnessRuntime<State>;
+  snapshot: AgentSessionSnapshot<State>;
+}
+interface AgentSessionOptions<State = unknown> {
+  agentSessionId?: string;
+  idFactory?: () => string;
+  now?: () => string;
+  store?: AgentSessionStore<State>;
+  compaction?: {
+    keepRecentTokens?: number;
+    preflightThresholdRatio?: number;
+  };
+  /**
+   * Maximum interval between snapshot writes while a turn is streaming. Writes
+   * always flush at action boundaries (turn end, abort, dispose); this only
+   * bounds staleness during streaming. Default 1000ms.
+   */
+  persistIntervalMs?: number;
+  /** Overrides for the transient-failure retry policy (see TurnRetryPolicy). */
+  retry?: Partial<TurnRetryPolicy>;
+}
+type SessionEvent = {
+  type: 'transcript_changed';
+  patches: TranscriptPatch[];
+  revision: number;
+} | {
+  type: 'phase_changed';
+  phase: SessionPhase;
+} | {
+  type: 'queue_changed';
+  queue: QueuedMessage[];
+} | {
+  type: 'tool_progress';
+  toolCallId: string;
+  toolName: string;
+  progress: unknown;
+} | {
+  type: 'retry_scheduled';
+  attempt: number;
+  delayMs: number;
+  code: string | null;
+} | {
+  type: 'error';
+  error: Error;
+};
+type SessionEventListener = (event: SessionEvent) => void;
+interface ExternalMutationReservation {
+  release(): void;
+}
+//#endregion
+//#region src/frames.d.ts
+/** A persisted conversation in a workspace (cwd), for the resume/history list. */
+interface ConversationSummary {
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+}
+type ClientFrame = {
+  type: 'open';
+  provider: ProviderSelection;
+  cwd: string;
+  sessionId: string;
+} | {
+  type: 'send';
+  messageId: string;
+  content: UserContentBlock[];
+} | {
+  type: 'dequeue_message';
+  messageId: string;
+} | {
+  type: 'send_queued_message';
+  messageId: string;
+} | {
+  type: 'steer_queued_message';
+  messageId: string;
+  steerId: string;
+} | {
+  type: 'clear_message_queue';
+} | {
+  type: 'steer';
+  steerId: string;
+  content: UserContentBlock[];
+} | {
+  type: 'cancel_pending_steer';
+  steerId: string;
+} | {
+  type: 'set_provider';
+  provider: ProviderSelection;
+} | {
+  type: 'abort';
+} | {
+  type: 'retry';
+} | {
+  type: 'resume';
+} | {
+  type: 'compact';
+} | {
+  type: 'shell_write';
+  commandId: string;
+  stdin: string;
+} | {
+  type: 'list_conversations';
+  cwd: string;
+} | {
+  type: 'sync_transcript';
+} | {
+  type: 'close';
+};
+type ServerFrame = {
+  type: 'opened';
+} | {
+  type: 'rejected';
+  command: string;
+  reason: string;
+} | {
+  type: 'transcript_snapshot';
+  blocks: Block[];
+  revision: number;
+} | {
+  type: 'transcript_patch';
+  patches: TranscriptPatch[];
+  revision: number;
+} | {
+  type: 'phase';
+  phase: SessionPhase;
+} | {
+  type: 'queue';
+  queue: QueuedMessage[];
+} | {
+  type: 'steer_result';
+  steerId: string;
+  status: 'accepted';
+} | {
+  type: 'steer_result';
+  steerId: string;
+  status: 'rejected';
+  reason: string;
+} | {
+  type: 'abort_result';
+  result: AbortResult;
+} | {
+  type: 'tool_progress';
+  toolUseId: string;
+  output: ToolResultContentBlock[];
+} | {
+  type: 'shell_output';
+  shellId: string;
+  commandId: string;
+  snapshot: ShellCommandSnapshotLike;
+} | {
+  type: 'shell_write_result';
+  commandId: string;
+  output: ToolResultContentBlock[];
+} | {
+  type: 'audit';
+  events: BashAuditEvent[];
+} | {
+  type: 'conversations';
+  conversations: ConversationSummary[];
+} | {
+  type: 'retry_scheduled';
+  attempt: number;
+  delayMs: number;
+  code: string | null;
+} | {
+  type: 'error';
+  message: string;
+  code?: string;
+} | {
+  type: 'closed';
+};
+/**
+ * Wire patches for transcript replication. Produced directly by the Transcript's
+ * mutation journal (never diff-derived). `append_text` carries streaming deltas
+ * for the `text` field of the block at the index (text/thinking blocks), keeping
+ * per-delta cost O(delta) instead of O(block) or O(transcript).
+ */
+type TranscriptPatch = {
+  op: 'add';
+  path: ['blocks', number];
+  value: Block;
+} | {
+  op: 'remove';
+  path: ['blocks', number];
+} | {
+  op: 'replace_block';
+  path: ['blocks', number];
+  value: Block;
+} | {
+  op: 'append_text';
+  path: ['blocks', number];
+  delta: string;
+} | {
+  op: 'replace';
+  path: ['blocks'];
+  value: Block[];
+};
+type ShellCommandSnapshotLike = ShellCommandSnapshot;
+type ClientSessionEvent = {
+  type: 'transcript_snapshot';
+  blocks: Block[];
+} | {
+  type: 'transcript_patch';
+  patches: TranscriptPatch[];
+  blocks: Block[];
+} | {
+  type: 'phase';
+  phase: SessionPhase;
+} | {
+  type: 'queue';
+  queue: QueuedMessage[];
+} | {
+  type: 'steer_result';
+  steerId: string;
+  status: 'accepted';
+} | {
+  type: 'steer_result';
+  steerId: string;
+  status: 'rejected';
+  reason: string;
+} | {
+  type: 'abort_result';
+  result: AbortResult;
+} | {
+  type: 'tool_progress';
+  toolUseId: string;
+  output: ToolResultContentBlock[];
+} | {
+  type: 'shell_output';
+  shellId: string;
+  commandId: string;
+  snapshot: ShellCommandSnapshotLike;
+} | {
+  type: 'shell_write_result';
+  commandId: string;
+  output: ToolResultContentBlock[];
+} | {
+  type: 'audit';
+  events: BashAuditEvent[];
+} | {
+  type: 'retry_scheduled';
+  attempt: number;
+  delayMs: number;
+  code: string | null;
+} | {
+  type: 'rejected';
+  command: string;
+  reason: string;
+} | {
+  type: 'error';
+  message: string;
+  code?: string;
+} | {
+  type: 'opened';
+} | {
+  type: 'closed';
+};
+//#endregion
+//#region src/transport.d.ts
+interface AgentTransport<SendFrame, ReceiveFrame> {
+  send(frame: SendFrame): void;
+  onFrame(handler: (frame: ReceiveFrame) => void): () => void;
+  close(): void;
+}
+type AgentClientTransport = AgentTransport<ClientFrame, ServerFrame>;
+type AgentServerTransport = AgentTransport<ServerFrame, ClientFrame>;
+interface InProcessTransportPair {
+  client: AgentClientTransport;
+  server: AgentServerTransport;
+}
+declare function createInProcessTransportPair(): InProcessTransportPair;
+//#endregion
+export { AgentToolInvokeResult as A, DEFAULT_TURN_RETRY_POLICY as B, AgentSessionRestoreParams as C, AgentTool as D, AgentSystemPromptContext as E, CompactionWindow as F, isRetryableCode as H, DrainedTranscriptPatches as I, Transcript$1 as L, SessionEvent as M, SessionEventListener as N, AgentToolContext as O, ToolContinuation as P, TranscriptOptions as R, AgentSessionParams as S, AgentSessionStore as T, resolveRetryPolicy as U, TurnRetryPolicy as V, retryDelayMs as W, AgentHarnessRuntime as _, createInProcessTransportPair as a, AgentReferenceResolveContext as b, ConversationSummary as c, TranscriptPatch as d, AbortResult as f, AgentHarnessContext as g, AgentHarness as h, InProcessTransportPair as i, ExternalMutationReservation as j, AgentToolInvokeContext as k, ServerFrame as l, AgentDisposeContext as m, AgentServerTransport as n, ClientFrame as o, AbortTarget as p, AgentTransport as r, ClientSessionEvent as s, AgentClientTransport as t, ShellCommandSnapshotLike as u, AgentLifecycleEvent as v, AgentSessionSnapshot as w, AgentSessionOptions as x, AgentPromptContext as y, estimateTranscriptBlockTokens as z };