twinny 0.0.0-dev.260525150705

package/dist/codex/turn.js

@@ -0,0 +1,746 @@
+import { TwinnyError, toErrorMessage } from "../errors.js";
+import { isThreadGoal } from "./goal.js";
+export function buildTextTurnInput(text) {
+    return {
+        type: "text",
+        text,
+        text_elements: []
+    };
+}
+export function buildLocalImageTurnInput(path) {
+    return {
+        type: "localImage",
+        path,
+        detail: null
+    };
+}
+export function normalizeCodexTurnInput(input, fallbackText = "") {
+    if (Array.isArray(input)) {
+        return input;
+    }
+    return [buildTextTurnInput(input ?? fallbackText)];
+}
+export function prefixCurrentThreadNameInput(input, threadName) {
+    const prefix = `<current_thread_name>${escapeXmlText(threadName)}</current_thread_name>\n`;
+    const firstTextIndex = input.findIndex((item) => item.type === "text");
+    if (firstTextIndex < 0) {
+        return [buildTextTurnInput(prefix), ...input];
+    }
+    return input.map((item, index) => {
+        if (index !== firstTextIndex || item.type !== "text") {
+            return item;
+        }
+        return {
+            ...item,
+            text: `${prefix}${item.text}`
+        };
+    });
+}
+export function buildTurnStartParams(options) {
+    const input = normalizeCodexTurnInput(options.input, options.text ?? "");
+    const params = {
+        threadId: options.threadId,
+        input: options.currentThreadName === undefined ? input : prefixCurrentThreadNameInput(input, options.currentThreadName),
+        cwd: options.cwd,
+        approvalPolicy: "never"
+    };
+    if (options.mode) {
+        params.collaborationMode = {
+            mode: options.mode,
+            settings: {
+                model: options.model ?? "gpt-5.5",
+                reasoning_effort: options.effort ?? "medium",
+                developer_instructions: null
+            }
+        };
+    }
+    return params;
+}
+export function buildTurnSteerParams(options) {
+    return {
+        threadId: options.threadId,
+        input: normalizeCodexTurnInput(options.input, options.text ?? ""),
+        expectedTurnId: options.turnId
+    };
+}
+export function buildTurnInterruptParams(options) {
+    return {
+        threadId: options.threadId,
+        turnId: options.turnId
+    };
+}
+export async function startCodexTurn(protocol, options, requestOptions = {}) {
+    const accumulator = new TurnOutputAccumulator(options.threadId, undefined, {
+        onTurnStarted: options.onTurnStarted,
+        onAgentMessage: options.onAgentMessage,
+        onImageGeneration: options.onImageGeneration,
+        onTokenUsage: options.onTokenUsage,
+        onGoalUpdated: options.onGoalUpdated,
+        onGoalCleared: options.onGoalCleared,
+        onPlanUpdated: options.onPlanUpdated
+    });
+    const onNotification = (notification) => {
+        accumulator.record(notification);
+    };
+    const onServerRequest = (request) => {
+        handleTurnServerRequest(protocol, options, request);
+    };
+    protocol.on("notification", onNotification);
+    protocol.on("serverRequest", onServerRequest);
+    try {
+        const response = await protocol.request("turn/start", buildTurnStartParams(options), { timeoutMs: requestOptions.requestTimeoutMs });
+        if (response.turn?.id) {
+            accumulator.setTurnId(response.turn.id, "response");
+        }
+        return await accumulator.wait(requestOptions.completionTimeoutMs);
+    }
+    catch (error) {
+        throw error instanceof Error
+            ? error
+            : new TwinnyError(toErrorMessage(error), "CODEX_TURN_FAILED", error);
+    }
+    finally {
+        protocol.off("notification", onNotification);
+        protocol.off("serverRequest", onServerRequest);
+    }
+}
+export async function compactCodexThread(protocol, options, requestOptions = {}) {
+    const accumulator = new TurnOutputAccumulator(options.threadId, undefined, {
+        onTurnStarted: options.onTurnStarted,
+        onTokenUsage: options.onTokenUsage
+    });
+    const onNotification = (notification) => {
+        accumulator.record(notification);
+    };
+    const onServerRequest = (request) => {
+        if (!requestMatchesThread(request, options.threadId)) {
+            return;
+        }
+        protocol.respondError(request.id, {
+            code: "TWINNY_UNSUPPORTED_SERVER_REQUEST",
+            message: `Twinny does not implement Codex server request ${request.method} during compact`
+        });
+    };
+    protocol.on("notification", onNotification);
+    protocol.on("serverRequest", onServerRequest);
+    try {
+        await protocol.request("thread/compact/start", { threadId: options.threadId }, { timeoutMs: requestOptions.requestTimeoutMs });
+        return await accumulator.wait(requestOptions.completionTimeoutMs);
+    }
+    catch (error) {
+        throw error instanceof Error
+            ? error
+            : new TwinnyError(toErrorMessage(error), "CODEX_TURN_FAILED", error);
+    }
+    finally {
+        protocol.off("notification", onNotification);
+        protocol.off("serverRequest", onServerRequest);
+    }
+}
+export async function steerCodexTurn(protocol, options) {
+    await protocol.request("turn/steer", buildTurnSteerParams(options));
+}
+export async function interruptCodexTurn(protocol, options) {
+    await protocol.request("turn/interrupt", buildTurnInterruptParams(options));
+}
+export class TurnOutputAccumulator {
+    threadId;
+    callbacks;
+    assistantMessages = new Map();
+    generatedImages = new Map();
+    pendingAgentMessageCallbacks = [];
+    agentMessageCallbackChain = Promise.resolve();
+    startedAt = Date.now();
+    finalAnswerText;
+    turnId;
+    turnIdSource;
+    emittedTurnStartedId;
+    completed;
+    completionError;
+    resolveWait;
+    rejectWait;
+    constructor(threadId, turnId, callbacks = {}) {
+        this.threadId = threadId;
+        this.callbacks = callbacks;
+        this.turnId = turnId;
+        this.turnIdSource = turnId ? "response" : undefined;
+    }
+    setTurnId(turnId, source = "notification") {
+        const canReplaceResponseTurnId = source === "notification" &&
+            this.turnIdSource === "response" &&
+            this.turnId !== undefined &&
+            this.turnId !== turnId;
+        if (!this.turnId || canReplaceResponseTurnId) {
+            this.turnId = turnId;
+            this.turnIdSource = source;
+        }
+        else if (!this.turnIdSource) {
+            this.turnIdSource = source;
+        }
+        if (this.emittedTurnStartedId !== this.turnId) {
+            this.emittedTurnStartedId = this.turnId;
+            void Promise.resolve(this.callbacks.onTurnStarted?.(this.turnId)).catch((error) => {
+                const parsedError = error instanceof Error ? error : new TwinnyError(toErrorMessage(error), "CODEX_TURN_STARTED_CALLBACK_FAILED");
+                this.completionError = parsedError;
+                this.rejectWait?.(parsedError);
+            });
+        }
+    }
+    record(notification) {
+        try {
+            if (notification.method === "turn/started") {
+                this.recordTurnStarted(notification.params);
+                return;
+            }
+            if (notification.method === "item/completed") {
+                this.recordItemCompleted(notification.params);
+                return;
+            }
+            if (notification.method === "turn/completed") {
+                this.recordTurnCompleted(notification.params);
+                return;
+            }
+            if (notification.method === "thread/tokenUsage/updated") {
+                this.recordTokenUsage(notification.params);
+                return;
+            }
+            if (notification.method === "thread/goal/updated") {
+                this.recordGoalUpdated(notification.params);
+                return;
+            }
+            if (notification.method === "thread/goal/cleared") {
+                this.recordGoalCleared(notification.params);
+                return;
+            }
+            if (notification.method === "error") {
+                this.recordError(notification.params);
+            }
+        }
+        catch (error) {
+            this.completionError =
+                error instanceof Error ? error : new TwinnyError(toErrorMessage(error), "CODEX_TURN_AGGREGATION_ERROR");
+            this.rejectWait?.(this.completionError);
+        }
+    }
+    wait(timeoutMs = 0) {
+        if (this.completionError) {
+            return Promise.reject(this.completionError);
+        }
+        if (this.completed) {
+            return this.waitForPendingAgentMessageCallbacks().then(() => this.toResult());
+        }
+        return new Promise((resolve, reject) => {
+            let timeout;
+            this.resolveWait = (result) => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                resolve(result);
+            };
+            this.rejectWait = (error) => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                reject(error);
+            };
+            if (timeoutMs > 0) {
+                timeout = setTimeout(() => {
+                    reject(new TwinnyError("Timed out waiting for Codex turn completion", "CODEX_TURN_TIMEOUT"));
+                }, timeoutMs);
+            }
+        });
+    }
+    get text() {
+        return Array.from(this.assistantMessages.values())
+            .map((text) => text.trim())
+            .filter((text) => text.length > 0)
+            .join("\n\n");
+    }
+    recordTurnStarted(params) {
+        if (!isRecord(params) || params.threadId !== this.threadId || !isRecord(params.turn)) {
+            return;
+        }
+        const turnId = stringValue(params.turn.id);
+        if (turnId) {
+            this.setTurnId(turnId, "notification");
+        }
+    }
+    recordItemCompleted(params) {
+        if (!isItemCompletedParams(params)) {
+            return;
+        }
+        if (params.threadId !== this.threadId) {
+            return;
+        }
+        if (params.turnId) {
+            this.setTurnId(params.turnId, "notification");
+        }
+        if (this.turnId && params.turnId && params.turnId !== this.turnId) {
+            return;
+        }
+        const plan = extractPlanUpdate(params);
+        if (plan) {
+            this.emitPlanUpdate(plan);
+            return;
+        }
+        const item = extractAgentMessage(params.item);
+        if (item) {
+            this.assistantMessages.set(item.id, item.text);
+            if (item.phase === "final_answer") {
+                this.finalAnswerText = item.text;
+            }
+            this.emitAgentMessage(item);
+            return;
+        }
+        const image = extractImageGeneration(params.item);
+        if (image) {
+            this.recordImageGeneration(image);
+            this.emitImageGeneration(image);
+        }
+    }
+    recordTurnCompleted(params) {
+        if (!isTurnCompletedParams(params)) {
+            return;
+        }
+        if (params.threadId !== this.threadId) {
+            return;
+        }
+        const completedTurnId = stringValue(params.turn.id);
+        if (completedTurnId) {
+            this.setTurnId(completedTurnId, "notification");
+        }
+        if (this.turnId && completedTurnId && completedTurnId !== this.turnId) {
+            return;
+        }
+        for (const item of params.turn.items ?? []) {
+            const message = extractAgentMessage(item);
+            if (message) {
+                this.assistantMessages.set(message.id, message.text);
+                if (message.phase === "final_answer") {
+                    this.finalAnswerText = message.text;
+                }
+                continue;
+            }
+            const image = extractImageGeneration(item);
+            if (image) {
+                this.recordImageGeneration(image);
+            }
+        }
+        this.completed = params;
+        void this.resolveCompleted();
+    }
+    recordError(params) {
+        if (isRetryableTurnError(params)) {
+            return;
+        }
+        const message = isRecord(params) && typeof params.message === "string"
+            ? params.message
+            : "Codex app-server reported an error";
+        this.completionError = new TwinnyError(message, "CODEX_TURN_FAILED", params);
+        this.rejectWait?.(this.completionError);
+    }
+    recordTokenUsage(params) {
+        if (!isRecord(params) || params.threadId !== this.threadId) {
+            return;
+        }
+        const totalTokens = extractTotalTokens(params);
+        if (totalTokens === undefined) {
+            return;
+        }
+        const usage = {
+            threadId: this.threadId,
+            turnId: stringValue(params.turnId),
+            totalTokens,
+            raw: params
+        };
+        void Promise.resolve(this.callbacks.onTokenUsage?.(usage)).catch((error) => {
+            const parsedError = error instanceof Error ? error : new TwinnyError(toErrorMessage(error), "CODEX_TOKEN_USAGE_CALLBACK_FAILED");
+            this.completionError = parsedError;
+            this.rejectWait?.(parsedError);
+        });
+    }
+    recordGoalUpdated(params) {
+        if (!isRecord(params) || params.threadId !== this.threadId || !isThreadGoal(params.goal)) {
+            return;
+        }
+        void Promise.resolve(this.callbacks.onGoalUpdated?.(params.goal, stringValue(params.turnId) ?? null)).catch((error) => {
+            const parsedError = error instanceof Error ? error : new TwinnyError(toErrorMessage(error), "CODEX_THREAD_GOAL_CALLBACK_FAILED");
+            this.completionError = parsedError;
+            this.rejectWait?.(parsedError);
+        });
+    }
+    recordGoalCleared(params) {
+        if (!isRecord(params) || params.threadId !== this.threadId) {
+            return;
+        }
+        void Promise.resolve(this.callbacks.onGoalCleared?.()).catch((error) => {
+            const parsedError = error instanceof Error ? error : new TwinnyError(toErrorMessage(error), "CODEX_THREAD_GOAL_CALLBACK_FAILED");
+            this.completionError = parsedError;
+            this.rejectWait?.(parsedError);
+        });
+    }
+    emitPlanUpdate(plan) {
+        this.setTurnId(plan.turnId);
+        void Promise.resolve(this.callbacks.onPlanUpdated?.(plan)).catch((error) => {
+            const parsedError = error instanceof Error ? error : new TwinnyError(toErrorMessage(error), "CODEX_PLAN_CALLBACK_FAILED");
+            this.completionError = parsedError;
+            this.rejectWait?.(parsedError);
+        });
+    }
+    toResult() {
+        const turn = this.completed?.turn;
+        const status = turn?.status === "failed" ? "failed" : turn?.status === "interrupted" ? "interrupted" : "completed";
+        const generatedImages = Array.from(this.generatedImages.values());
+        return {
+            threadId: this.threadId,
+            turnId: this.turnId,
+            text: this.finalAnswerText ?? this.text,
+            status,
+            error: status === "failed" ? extractErrorMessage(turn?.error) : undefined,
+            durationMs: typeof turn?.durationMs === "number" ? turn.durationMs : Date.now() - this.startedAt,
+            ...(generatedImages.length > 0 ? { generatedImages } : {})
+        };
+    }
+    recordImageGeneration(image) {
+        this.generatedImages.set(image.id, image);
+    }
+    emitAgentMessage(message) {
+        if (!this.callbacks.onAgentMessage) {
+            return;
+        }
+        const pending = this.agentMessageCallbackChain
+            .then(() => this.callbacks.onAgentMessage?.(message))
+            .catch((error) => {
+            const parsedError = error instanceof Error ? error : new TwinnyError(toErrorMessage(error), "CODEX_AGENT_MESSAGE_CALLBACK_FAILED");
+            this.completionError = parsedError;
+            this.rejectWait?.(parsedError);
+        });
+        this.agentMessageCallbackChain = pending.then(() => undefined);
+        this.pendingAgentMessageCallbacks.push(pending);
+    }
+    emitImageGeneration(image) {
+        if (!this.callbacks.onImageGeneration) {
+            return;
+        }
+        const pending = this.agentMessageCallbackChain
+            .then(() => this.callbacks.onImageGeneration?.(image))
+            .catch((error) => {
+            const parsedError = error instanceof Error ? error : new TwinnyError(toErrorMessage(error), "CODEX_IMAGE_GENERATION_CALLBACK_FAILED");
+            this.completionError = parsedError;
+            this.rejectWait?.(parsedError);
+        });
+        this.agentMessageCallbackChain = pending.then(() => undefined);
+        this.pendingAgentMessageCallbacks.push(pending);
+    }
+    async resolveCompleted() {
+        await this.waitForPendingAgentMessageCallbacks();
+        if (this.completionError) {
+            this.rejectWait?.(this.completionError);
+            return;
+        }
+        this.resolveWait?.(this.toResult());
+    }
+    async waitForPendingAgentMessageCallbacks() {
+        await Promise.all(this.pendingAgentMessageCallbacks);
+    }
+}
+function extractAgentMessage(item) {
+    if (!isRecord(item) || item.type !== "agentMessage") {
+        return undefined;
+    }
+    const id = stringValue(item.id);
+    const text = stringValue(item.text);
+    if (!id || text === undefined) {
+        return undefined;
+    }
+    const phase = agentMessagePhaseValue(item.phase);
+    return phase === undefined ? { id, text } : { id, text, phase };
+}
+function extractImageGeneration(item) {
+    if (!isRecord(item) || item.type !== "imageGeneration") {
+        return undefined;
+    }
+    const id = stringValue(item.id);
+    if (!id) {
+        return undefined;
+    }
+    const status = stringValue(item.status);
+    const savedPath = stringValue(item.savedPath) ?? stringValue(item.saved_path);
+    const revisedPrompt = stringValue(item.revisedPrompt) ?? stringValue(item.revised_prompt);
+    const result = stringValue(item.result);
+    return {
+        id,
+        ...(status ? { status } : {}),
+        ...(savedPath ? { savedPath } : {}),
+        ...(revisedPrompt ? { revisedPrompt } : {}),
+        ...(result ? { result } : {})
+    };
+}
+function extractPlanUpdate(params) {
+    const turnId = stringValue(params.turnId);
+    if (!turnId || !isRecord(params.item) || params.item.type !== "plan") {
+        return undefined;
+    }
+    const text = stringValue(params.item.text);
+    if (text === undefined) {
+        return undefined;
+    }
+    return {
+        threadId: params.threadId,
+        turnId,
+        explanation: text,
+        plan: []
+    };
+}
+export function handleTurnServerRequest(protocol, options, request) {
+    if (request.method === "item/tool/call") {
+        handleDynamicToolCallRequest(protocol, options, request);
+        return;
+    }
+    if (request.method !== "item/tool/requestUserInput") {
+        if (requestMatchesThread(request, options.threadId)) {
+            protocol.respondError(request.id, {
+                code: "TWINNY_UNSUPPORTED_SERVER_REQUEST",
+                message: `Twinny does not implement Codex server request ${request.method}`
+            });
+        }
+        return;
+    }
+    const params = parseRequestUserInputParams(request.params);
+    if (!params || params.threadId !== options.threadId) {
+        return;
+    }
+    if (!options.onRequestUserInput) {
+        protocol.respondError(request.id, {
+            code: "TWINNY_UNSUPPORTED_SERVER_REQUEST",
+            message: "Twinny does not implement item/tool/requestUserInput for this turn"
+        });
+        return;
+    }
+    let settled = false;
+    const responder = {
+        respond: (response) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            protocol.respond(request.id, response);
+        },
+        reject: (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            protocol.respondError(request.id, {
+                code: "TWINNY_REQUEST_USER_INPUT_FAILED",
+                message: typeof error === "string" ? error : error.message
+            });
+        }
+    };
+    void Promise.resolve(options.onRequestUserInput({
+        requestId: request.id,
+        params
+    }, responder)).catch((error) => {
+        responder.reject(error instanceof Error ? error : toErrorMessage(error));
+    });
+}
+function handleDynamicToolCallRequest(protocol, options, request) {
+    const params = parseDynamicToolCallParams(request.params);
+    if (!params) {
+        if (requestMatchesThread(request, options.threadId)) {
+            protocol.respondError(request.id, {
+                code: "TWINNY_INVALID_DYNAMIC_TOOL_CALL",
+                message: "Invalid Codex dynamic tool call request"
+            });
+        }
+        return;
+    }
+    if (params.threadId !== options.threadId) {
+        return;
+    }
+    if (params.namespace !== "twinny" || params.tool !== "set_thread_name") {
+        protocol.respondError(request.id, {
+            code: "TWINNY_UNSUPPORTED_SERVER_REQUEST",
+            message: `Twinny does not implement dynamic tool ${params.namespace ? `${params.namespace}.` : ""}${params.tool}`
+        });
+        return;
+    }
+    if (!options.onSetThreadName) {
+        protocol.respondError(request.id, {
+            code: "TWINNY_UNSUPPORTED_SERVER_REQUEST",
+            message: "Twinny does not implement twinny.set_thread_name for this turn"
+        });
+        return;
+    }
+    const name = parseSetThreadNameArguments(params.arguments);
+    if (!name) {
+        protocol.respond(request.id, dynamicToolTextResponse(false, "Invalid thread name: expected a non-empty name string."));
+        return;
+    }
+    void Promise.resolve(options.onSetThreadName({
+        requestId: request.id,
+        threadId: params.threadId,
+        turnId: params.turnId,
+        callId: params.callId,
+        name,
+        rawArguments: params.arguments
+    })).then((response) => protocol.respond(request.id, response), (error) => {
+        protocol.respond(request.id, dynamicToolTextResponse(false, `Failed to update thread name: ${toErrorMessage(error)}`));
+    });
+}
+function requestMatchesThread(request, threadId) {
+    return isRecord(request.params) && request.params.threadId === threadId;
+}
+function parseDynamicToolCallParams(value) {
+    if (!isRecord(value) ||
+        typeof value.threadId !== "string" ||
+        typeof value.turnId !== "string" ||
+        typeof value.callId !== "string" ||
+        typeof value.tool !== "string") {
+        return undefined;
+    }
+    if (value.namespace !== null && typeof value.namespace !== "string") {
+        return undefined;
+    }
+    return {
+        threadId: value.threadId,
+        turnId: value.turnId,
+        callId: value.callId,
+        namespace: value.namespace,
+        tool: value.tool,
+        arguments: value.arguments
+    };
+}
+function parseSetThreadNameArguments(value) {
+    if (!isRecord(value) || typeof value.name !== "string") {
+        return undefined;
+    }
+    const name = value.name.replace(/\s+/g, " ").trim();
+    return name || undefined;
+}
+export function dynamicToolTextResponse(success, text) {
+    return {
+        success,
+        contentItems: [{ type: "inputText", text }]
+    };
+}
+function escapeXmlText(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function parseRequestUserInputParams(value) {
+    if (!isRecord(value) || typeof value.threadId !== "string" || typeof value.turnId !== "string") {
+        return undefined;
+    }
+    if (typeof value.itemId !== "string" || !Array.isArray(value.questions)) {
+        return undefined;
+    }
+    const questions = value.questions.map(parseRequestUserInputQuestion);
+    if (questions.some((question) => question === undefined)) {
+        return undefined;
+    }
+    return {
+        threadId: value.threadId,
+        turnId: value.turnId,
+        itemId: value.itemId,
+        questions: questions
+    };
+}
+function parseRequestUserInputQuestion(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const { id, header, question, isOther, isSecret, options } = value;
+    if (typeof id !== "string" ||
+        typeof header !== "string" ||
+        typeof question !== "string" ||
+        typeof isOther !== "boolean" ||
+        typeof isSecret !== "boolean") {
+        return undefined;
+    }
+    if (options !== null && options !== undefined && !Array.isArray(options)) {
+        return undefined;
+    }
+    const parsedOptions = (options ?? null) === null
+        ? null
+        : options.map((option) => {
+            if (!isRecord(option) || typeof option.label !== "string" || typeof option.description !== "string") {
+                return undefined;
+            }
+            return { label: option.label, description: option.description };
+        });
+    if (Array.isArray(parsedOptions) && parsedOptions.some((option) => option === undefined)) {
+        return undefined;
+    }
+    return {
+        id,
+        header,
+        question,
+        isOther,
+        isSecret,
+        options: parsedOptions
+    };
+}
+function agentMessagePhaseValue(value) {
+    if (value === null) {
+        return null;
+    }
+    return value === "commentary" || value === "final_answer" ? value : undefined;
+}
+function extractErrorMessage(error) {
+    if (!error) {
+        return undefined;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (isRecord(error) && typeof error.message === "string") {
+        return error.message;
+    }
+    return String(error);
+}
+export function extractTotalTokens(params) {
+    return firstFiniteNumber(params.totalTokens, params.total_tokens, nestedValue(params, ["usage", "totalTokens"]), nestedValue(params, ["usage", "total_tokens"]), nestedValue(params, ["usage", "total", "totalTokens"]), nestedValue(params, ["usage", "total", "total_tokens"]), nestedValue(params, ["total", "totalTokens"]), nestedValue(params, ["total", "total_tokens"]), nestedValue(params, ["tokenUsage", "totalTokens"]), nestedValue(params, ["tokenUsage", "total_tokens"]), nestedValue(params, ["tokenUsage", "total", "totalTokens"]), nestedValue(params, ["tokenUsage", "total", "total_tokens"]));
+}
+function nestedValue(record, path) {
+    let current = record;
+    for (const key of path) {
+        if (!isRecord(current)) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+function firstFiniteNumber(...values) {
+    for (const value of values) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === "string" && value.trim() !== "") {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return undefined;
+}
+function isTurnCompletedParams(value) {
+    return isRecord(value) && typeof value.threadId === "string" && isRecord(value.turn);
+}
+function isItemCompletedParams(value) {
+    return isRecord(value) && typeof value.threadId === "string";
+}
+function isRetryableTurnError(value) {
+    return isRecord(value) && value.willRetry === true;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=turn.js.map