veryfront 0.1.516 → 0.1.518

package/esm/src/agent/conversation/delegation-policy.js

@@ -0,0 +1,192 @@
+import { extractLatestUserText } from "../default-research-artifact-support.js";
+import { buildRootOwnedChildRunResultHint } from "../child-run/result-summary.js";
+import { isRecord } from "../../chat/conversation.js";
+export const KEEP_ROOT_ASSISTANT_VISIBLE_OWNER = "Keep the root assistant visibly owning the work.";
+export const DELEGATE_ONLY_WHEN_MATERIALLY_HELPFUL = "Delegate only when isolation, parallelism, or a different tool/model budget materially helps.";
+export const NO_DELEGATION_NARRATION_UNLESS_ASKED = "Do not mention child agents, delegation, or tool/process narration unless the user explicitly asks about them.";
+export const SYNTHESIZE_DELEGATED_FINDINGS_IN_ROOT_VOICE = "After delegated work returns, synthesize the findings in the root assistant voice.";
+export const LOAD_SKILL_CONTINUE_SAME_TURN = "Continue the same turn after calling it.";
+export const LOAD_SKILL_CONTINUE_SAME_TURN_NOW = "Continue the same turn now.";
+export const LOAD_SKILL_ROOT_OWNERSHIP = KEEP_ROOT_ASSISTANT_VISIBLE_OWNER;
+export const LOAD_SKILL_USE_ALLOWED_TOOLS = "For multi-step or isolated work, call invoke_agent; otherwise keep working directly with the allowed tools.";
+export const LOAD_SKILL_DELEGATION_THRESHOLD = DELEGATE_ONLY_WHEN_MATERIALLY_HELPFUL;
+export const LOAD_SKILL_OVERRIDE_FORWARDING = "Pass through any returned model, thinking, or maxSteps overrides to invoke_agent when delegating.";
+export const LOAD_SKILL_TOOL_INTERSECTION = "If the current run exposes fewer tools than the loaded skill metadata, use only the tools that are actually available right now.";
+export function buildRootOwnedDelegatedFindingsInstruction() {
+    return `Use these delegated findings directly in your next assistant response. ${KEEP_ROOT_ASSISTANT_VISIBLE_OWNER} ${NO_DELEGATION_NARRATION_UNLESS_ASKED}`;
+}
+export const ROOT_OWNED_CHILD_RESULT_INSTRUCTION = buildRootOwnedDelegatedFindingsInstruction();
+export function buildRootOwnedChildResultHint(text) {
+    return buildRootOwnedChildRunResultHint({
+        text,
+        instruction: ROOT_OWNED_CHILD_RESULT_INSTRUCTION,
+    });
+}
+function getRootOwnedChildResultText(result) {
+    if (!isRecord(result)) {
+        return null;
+    }
+    if (result.status === "completed" &&
+        typeof result.text === "string" &&
+        result.text.length > 0) {
+        return result.text;
+    }
+    if (!result.success || !isRecord(result.summary)) {
+        return null;
+    }
+    return typeof result.summary.text === "string" && result.summary.text.length > 0
+        ? result.summary.text
+        : null;
+}
+export function withRootOwnedChildResultHint(result) {
+    const text = getRootOwnedChildResultText(result);
+    if (!text) {
+        return result;
+    }
+    return {
+        ...result,
+        rootResponseHint: buildRootOwnedChildResultHint(text),
+    };
+}
+export function buildInvokeAgentFollowupInstruction() {
+    return `${SYNTHESIZE_DELEGATED_FINDINGS_IN_ROOT_VOICE} ${NO_DELEGATION_NARRATION_UNLESS_ASKED}`;
+}
+export function buildStarterIntentRootOwnershipReminder() {
+    return `CRITICAL: For first-turn /plan and /research starter requests, keep the root assistant visibly owning the work, continue in the same turn after load_skill, and delegate only when isolation, parallelism, or a different tool/model budget materially helps.`;
+}
+export function buildStarterIntentRootOwnershipBlockMessage() {
+    return `Keep the first /plan or /research turn root-owned. Continue in the main thread after load_skill, explain the approach first, and delegate only when isolation, parallelism, or a different tool/model budget materially helps.`;
+}
+export const LOAD_SKILL_CONTINUATION_REMINDER = `CRITICAL: load_skill only loaded instructions. ${LOAD_SKILL_CONTINUE_SAME_TURN_NOW} ${LOAD_SKILL_ROOT_OWNERSHIP} Use the loaded skill guidance to proceed. ${LOAD_SKILL_DELEGATION_THRESHOLD} Do not stop immediately after load_skill.`;
+export const SLASH_COMMAND_ARTIFACT_REMINDER = `CRITICAL: This slash-command task names an exact artifact path. ${LOAD_SKILL_ROOT_OWNERSHIP} Treat that path as a required deliverable, and continue in the same turn. Delegate only when isolation materially helps.`;
+const RICH_TEXT_COMMAND_PATTERN = /<span\s+data-command="([^"]+)">\s*\/([a-z0-9_-]+)\s*<\/span>/gi;
+const STARTER_INTENT_PATTERN = /^\s*\/([a-z0-9_-]+)\b/i;
+const CONVERSATION_FIRST_STARTER_INTENT_IDS = new Set(["plan", "research"]);
+export const FIRST_TURN_STARTER_INTENT_ROOT_OWNERSHIP_REMINDER = buildStarterIntentRootOwnershipReminder();
+export const FIRST_TURN_STARTER_INTENT_ROOT_OWNERSHIP_CONTEXT_KEY = "__vfStarterIntentRootOwnership";
+export const FIRST_TURN_STARTER_INTENT_ROOT_OWNERSHIP_BLOCK_MESSAGE = buildStarterIntentRootOwnershipBlockMessage();
+function isToolCallPart(part) {
+    return (isRecord(part) &&
+        part.type === "tool-call" &&
+        typeof part.toolCallId === "string" &&
+        typeof part.toolName === "string");
+}
+function isToolResultPart(part) {
+    return isRecord(part) && part.type === "tool-result" && typeof part.toolCallId === "string";
+}
+function hasNonEmptyTextPart(part) {
+    return isRecord(part) && part.type === "text" && typeof part.text === "string" &&
+        part.text.trim().length > 0;
+}
+function hasToolCallOrResult(messages, toolName) {
+    return messages.some((message) => {
+        if (!isRecord(message) || !Array.isArray(message.content)) {
+            return false;
+        }
+        return message.content.some((part) => {
+            if (!isRecord(part) || typeof part.toolName !== "string") {
+                return false;
+            }
+            return (part.type === "tool-call" || part.type === "tool-result") &&
+                part.toolName === toolName;
+        });
+    });
+}
+export function extractStarterIntentId(messages) {
+    const latestUserText = extractLatestUserText(messages);
+    if (!latestUserText) {
+        return null;
+    }
+    const normalizedText = latestUserText.replace(RICH_TEXT_COMMAND_PATTERN, (_match, _dataCommand, slashCommand) => {
+        return `/${slashCommand}`;
+    });
+    const commandId = STARTER_INTENT_PATTERN.exec(normalizedText)?.[1] ?? null;
+    return commandId ? commandId.toLowerCase() : null;
+}
+export function evaluateStarterIntentTurnPolicy(input) {
+    const starterIntentId = extractStarterIntentId(input.messages);
+    const keepConversationFirst = input.step === 1 && starterIntentId !== null &&
+        CONVERSATION_FIRST_STARTER_INTENT_IDS.has(starterIntentId);
+    const invokeAgentStarted = keepConversationFirst &&
+        hasToolCallOrResult(input.messages, "invoke_agent");
+    return {
+        starterIntentId,
+        keepConversationFirst,
+        shouldAddRootOwnershipReminder: keepConversationFirst && !invokeAgentStarted,
+        shouldBlockImmediateDelegation: keepConversationFirst,
+    };
+}
+export function addFirstTurnStarterIntentRootOwnershipReminder(system) {
+    if (system.includes(FIRST_TURN_STARTER_INTENT_ROOT_OWNERSHIP_REMINDER)) {
+        return system;
+    }
+    return `${system}\n\n${FIRST_TURN_STARTER_INTENT_ROOT_OWNERSHIP_REMINDER}`;
+}
+export function isStarterIntentRootOwnershipRequired(value) {
+    return value === true;
+}
+export function shouldReinforceLoadSkillContinuation(messages) {
+    const lastMessage = messages.at(-1);
+    const previousMessage = messages.at(-2);
+    if (!isRecord(lastMessage) || lastMessage.role !== "tool" ||
+        !Array.isArray(lastMessage.content)) {
+        return false;
+    }
+    if (!isRecord(previousMessage) || previousMessage.role !== "assistant" ||
+        !Array.isArray(previousMessage.content)) {
+        return false;
+    }
+    const toolCalls = [];
+    for (const part of previousMessage.content) {
+        if (isToolCallPart(part)) {
+            toolCalls.push(part);
+        }
+    }
+    const loadSkillCalls = toolCalls.filter((part) => part.toolName === "load_skill");
+    if (loadSkillCalls.length === 0) {
+        return false;
+    }
+    if (previousMessage.content.some(hasNonEmptyTextPart)) {
+        return false;
+    }
+    if (toolCalls.some((part) => part.toolName !== "load_skill")) {
+        return false;
+    }
+    const completedToolCallIds = new Set();
+    for (const part of lastMessage.content) {
+        if (isToolResultPart(part)) {
+            completedToolCallIds.add(part.toolCallId);
+        }
+    }
+    return loadSkillCalls.every((part) => completedToolCallIds.has(part.toolCallId));
+}
+export function addLoadSkillContinuationReminder(instructions) {
+    if (typeof instructions === "string") {
+        return `${instructions}\n\n${LOAD_SKILL_CONTINUATION_REMINDER}`;
+    }
+    if (instructions.some((message) => message.content.includes(LOAD_SKILL_CONTINUATION_REMINDER))) {
+        return instructions;
+    }
+    return [
+        ...instructions,
+        {
+            role: "system",
+            content: LOAD_SKILL_CONTINUATION_REMINDER,
+        },
+    ];
+}
+export function addSlashCommandArtifactReminder(instructions) {
+    if (typeof instructions === "string") {
+        return `${instructions}\n\n${SLASH_COMMAND_ARTIFACT_REMINDER}`;
+    }
+    if (instructions.some((message) => message.content.includes(SLASH_COMMAND_ARTIFACT_REMINDER))) {
+        return instructions;
+    }
+    return [
+        ...instructions,
+        {
+            role: "system",
+            content: SLASH_COMMAND_ARTIFACT_REMINDER,
+        },
+    ];
+}

package/esm/src/agent/conversation/hosted-lifecycle.d.ts

@@ -0,0 +1,39 @@
+import { type ConversationAgentRunUsage, type ConversationRunProjection } from "../durable.js";
+import { type InvokeAgentChildRunProgressEvent, type InvokeAgentChildRunProgressInput } from "../invoke-agent-child-runs.js";
+import type { ChatStreamEvent } from "../../chat/protocol.js";
+import type { HostedChildLifecycleAdapter } from "../hosted/child-lifecycle.js";
+import type { HostedLifecycleAdapter, HostedLifecycleTerminalState } from "../hosted/lifecycle.js";
+export interface ConversationHostedLifecycleFinalizeInput {
+    model: string;
+    provider: string;
+    usage?: ConversationAgentRunUsage;
+    terminalErrorCode?: string | null;
+    terminalErrorMessage?: string | null;
+}
+export interface CreateConversationHostedLifecycleAdapterOptions<TChunk> {
+    authToken: string;
+    apiUrl: string;
+    startRun: (input: {
+        abortSignal: AbortSignal;
+    }) => Promise<ConversationRunProjection> | ConversationRunProjection;
+    mapChunkToEvents?: (chunk: TChunk, run: ConversationRunProjection) => Promise<readonly unknown[] | unknown[]> | readonly unknown[] | unknown[];
+    resolveFinalizeInput: (input: {
+        run: ConversationRunProjection;
+        terminalState: HostedLifecycleTerminalState;
+    }) => Promise<ConversationHostedLifecycleFinalizeInput> | ConversationHostedLifecycleFinalizeInput;
+}
+export declare function createConversationHostedLifecycleAdapter<TChunk>(options: CreateConversationHostedLifecycleAdapterOptions<TChunk>): HostedLifecycleAdapter<ConversationRunProjection, TChunk>;
+export declare function createConversationHostedStreamLifecycleAdapter(options: Omit<CreateConversationHostedLifecycleAdapterOptions<ChatStreamEvent>, "mapChunkToEvents">): HostedLifecycleAdapter<ConversationRunProjection, ChatStreamEvent>;
+export interface ConversationChildLifecycleContext {
+    authToken: string;
+    apiUrl: string;
+    parentConversationId: string;
+    parentRunId: string;
+    projectId?: string | null;
+    publishParentRunEvents?: (events: InvokeAgentChildRunProgressEvent[]) => Promise<void> | void;
+    progress: Omit<InvokeAgentChildRunProgressInput, "status">;
+    model: string;
+    provider: string;
+}
+export declare function createConversationChildLifecycleAdapter(ctx: ConversationChildLifecycleContext): HostedChildLifecycleAdapter;
+//# sourceMappingURL=hosted-lifecycle.d.ts.map

package/esm/src/agent/conversation/hosted-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/conversation/hosted-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAE/B,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,KAAK,gCAAgC,EACrC,KAAK,gCAAgC,EAEtC,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAEnG,MAAM,WAAW,wCAAwC;IACvD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,yBAAyB,CAAC;IAClC,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,MAAM,WAAW,+CAA+C,CAAC,MAAM;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,CACR,KAAK,EAAE;QAAE,WAAW,EAAE,WAAW,CAAA;KAAE,KAChC,OAAO,CAAC,yBAAyB,CAAC,GAAG,yBAAyB,CAAC;IACpE,gBAAgB,CAAC,EAAE,CACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,yBAAyB,KAC3B,OAAO,CAAC,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC,GAAG,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC;IAC9E,oBAAoB,EAAE,CAAC,KAAK,EAAE;QAC5B,GAAG,EAAE,yBAAyB,CAAC;QAC/B,aAAa,EAAE,4BAA4B,CAAC;KAC7C,KACG,OAAO,CAAC,wCAAwC,CAAC,GACjD,wCAAwC,CAAC;CAC9C;AAED,wBAAgB,wCAAwC,CAAC,MAAM,EAC7D,OAAO,EAAE,+CAA+C,CAAC,MAAM,CAAC,GAC/D,sBAAsB,CAAC,yBAAyB,EAAE,MAAM,CAAC,CAuD3D;AAED,wBAAgB,8CAA8C,CAC5D,OAAO,EAAE,IAAI,CACX,+CAA+C,CAAC,eAAe,CAAC,EAChE,kBAAkB,CACnB,GACA,sBAAsB,CAAC,yBAAyB,EAAE,eAAe,CAAC,CAKpE;AAED,MAAM,WAAW,iCAAiC;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,sBAAsB,CAAC,EAAE,CAAC,MAAM,EAAE,gCAAgC,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC9F,QAAQ,EAAE,IAAI,CAAC,gCAAgC,EAAE,QAAQ,CAAC,CAAC;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAoCD,wBAAgB,uCAAuC,CACrD,GAAG,EAAE,iCAAiC,GACrC,2BAA2B,CAkD7B"}

package/esm/src/agent/conversation/hosted-lifecycle.js

@@ -0,0 +1,138 @@
+import { appendConversationRunEvents, finalizeConversationAgentRun, } from "../durable.js";
+import { prepareConversationRunStreamEvents } from "./run-event-preparation.js";
+import { publishInvokeAgentChildRunProgress, } from "../invoke-agent-child-runs.js";
+export function createConversationHostedLifecycleAdapter(options) {
+    return {
+        startRun: options.startRun,
+        appendEvents: options.mapChunkToEvents
+            ? async (run, chunk) => {
+                const events = [...await options.mapChunkToEvents(chunk, run)];
+                if (events.length === 0) {
+                    return;
+                }
+                const appended = await appendConversationRunEvents({
+                    authToken: options.authToken,
+                    apiUrl: options.apiUrl,
+                    conversationId: run.conversationId,
+                    runId: run.runId,
+                    expectedPreviousEventId: run.latestEventId,
+                    expectedPreviousExternalEventSequence: run.latestExternalEventSequence,
+                    events,
+                });
+                run.latestEventId = appended.latestEventId;
+                run.latestExternalEventSequence = appended.latestExternalEventSequence;
+            }
+            : undefined,
+        finalizeRun: async (run, terminalState) => {
+            const finalizeInput = await options.resolveFinalizeInput({ run, terminalState });
+            await finalizeConversationAgentRun({
+                authToken: options.authToken,
+                apiUrl: options.apiUrl,
+                conversationId: run.conversationId,
+                runId: run.runId,
+                status: terminalState.status,
+                model: finalizeInput.model,
+                provider: finalizeInput.provider,
+                usage: finalizeInput.usage,
+                terminalErrorCode: finalizeInput.terminalErrorCode,
+                terminalErrorMessage: finalizeInput.terminalErrorMessage,
+            });
+        },
+        cancelRun: async (run, terminalState) => {
+            const finalizeInput = await options.resolveFinalizeInput({ run, terminalState });
+            await finalizeConversationAgentRun({
+                authToken: options.authToken,
+                apiUrl: options.apiUrl,
+                conversationId: run.conversationId,
+                runId: run.runId,
+                status: "cancelled",
+                model: finalizeInput.model,
+                provider: finalizeInput.provider,
+                usage: finalizeInput.usage,
+                terminalErrorCode: finalizeInput.terminalErrorCode,
+                terminalErrorMessage: finalizeInput.terminalErrorMessage,
+            });
+        },
+    };
+}
+export function createConversationHostedStreamLifecycleAdapter(options) {
+    return createConversationHostedLifecycleAdapter({
+        ...options,
+        mapChunkToEvents: (chunk) => prepareConversationRunStreamEvents([chunk]),
+    });
+}
+function toConversationChildUsage(usage) {
+    if (!usage) {
+        return undefined;
+    }
+    const inputTokens = usage.inputTokens ?? 0;
+    const outputTokens = usage.outputTokens ?? 0;
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: usage.totalTokens ?? inputTokens + outputTokens,
+    };
+}
+async function publishConversationChildProgress(ctx, status) {
+    await publishInvokeAgentChildRunProgress({
+        authToken: ctx.authToken,
+        apiUrl: ctx.apiUrl,
+        conversationId: ctx.parentConversationId,
+        runId: ctx.parentRunId,
+        ...(ctx.projectId !== undefined ? { projectId: ctx.projectId } : {}),
+        ...ctx.progress,
+        status,
+        ...(ctx.publishParentRunEvents ? { publishParentRunEvents: ctx.publishParentRunEvents } : {}),
+    });
+}
+export function createConversationChildLifecycleAdapter(ctx) {
+    return {
+        pending: () => publishConversationChildProgress(ctx, "pending"),
+        running: () => publishConversationChildProgress(ctx, "running"),
+        completed: async (terminalState) => {
+            await finalizeConversationAgentRun({
+                authToken: ctx.authToken,
+                apiUrl: ctx.apiUrl,
+                conversationId: ctx.progress.childConversationId,
+                runId: ctx.progress.childRunId,
+                status: "completed",
+                model: ctx.model,
+                provider: ctx.provider,
+                usage: toConversationChildUsage(terminalState.usage),
+                terminalErrorCode: null,
+                terminalErrorMessage: null,
+            });
+            await publishConversationChildProgress(ctx, "completed");
+        },
+        failed: async (terminalState) => {
+            await finalizeConversationAgentRun({
+                authToken: ctx.authToken,
+                apiUrl: ctx.apiUrl,
+                conversationId: ctx.progress.childConversationId,
+                runId: ctx.progress.childRunId,
+                status: "failed",
+                model: ctx.model,
+                provider: ctx.provider,
+                usage: toConversationChildUsage(terminalState.usage),
+                terminalErrorCode: terminalState.terminalErrorCode ?? "FAILED",
+                terminalErrorMessage: terminalState.terminalErrorMessage ?? "Unknown error",
+            });
+            await publishConversationChildProgress(ctx, "failed");
+        },
+        cancelled: async (terminalState) => {
+            await finalizeConversationAgentRun({
+                authToken: ctx.authToken,
+                apiUrl: ctx.apiUrl,
+                conversationId: ctx.progress.childConversationId,
+                runId: ctx.progress.childRunId,
+                status: "cancelled",
+                model: ctx.model,
+                provider: ctx.provider,
+                usage: toConversationChildUsage(terminalState.usage),
+                terminalErrorCode: terminalState.terminalErrorCode ?? "CANCELLED",
+                terminalErrorMessage: terminalState.terminalErrorMessage ?? "Child run cancelled",
+            });
+            await publishConversationChildProgress(ctx, "cancelled");
+        },
+    };
+}

package/esm/src/agent/conversation/hosted-terminal.d.ts

@@ -0,0 +1,46 @@
+import { type ConversationRunProjection } from "../durable.js";
+import type { HostedLifecycleTerminalState } from "../hosted/lifecycle.js";
+export interface ConversationHostedTerminalStateInput {
+    status: HostedLifecycleTerminalState["status"];
+    metadata?: HostedLifecycleTerminalState["metadata"];
+    terminalErrorCode?: string | null;
+    terminalErrorMessage?: string | null;
+}
+export declare const CONVERSATION_HOSTED_STREAM_ERROR_TERMINAL_ERROR_CODE = "STREAM_ERROR";
+export declare const CONVERSATION_HOSTED_ABORTED_TERMINAL_ERROR_CODE = "ABORTED";
+export declare const CONVERSATION_HOSTED_INCOMPLETE_TOOL_CALLS_TERMINAL_ERROR_CODE = "INCOMPLETE_TOOL_CALLS";
+export interface ResolveConversationHostedTerminalStateInput {
+    isAborted: boolean;
+    hasIncompleteToolParts: boolean;
+    abortedTerminalErrorMessage?: string;
+    incompleteToolCallsTerminalErrorMessage?: string;
+}
+export type ConversationHostedTerminalStateResolution = Pick<ConversationHostedTerminalStateInput, "status" | "terminalErrorCode" | "terminalErrorMessage">;
+export declare function resolveConversationHostedTerminalState(input: ResolveConversationHostedTerminalStateInput): ConversationHostedTerminalStateResolution;
+export declare function resolveConversationHostedStreamErrorState(error: unknown): ConversationHostedTerminalStateResolution;
+export interface ConversationHostedTerminalRuntimeAdapter {
+    terminal: Pick<ConversationHostedTerminalAdapter, "toTerminalState" | "finalizeRun" | "cancelRun" | "onTerminalState">;
+}
+export declare function dispatchConversationHostedTerminalState(adapter: ConversationHostedTerminalRuntimeAdapter, state: ConversationHostedTerminalStateInput): Promise<HostedLifecycleTerminalState>;
+export declare function dispatchConversationHostedStreamErrorState(adapter: ConversationHostedTerminalRuntimeAdapter, error: unknown): Promise<HostedLifecycleTerminalState>;
+export interface CreateConversationHostedTerminalAdapterOptions {
+    authToken: string;
+    apiUrl: string;
+    run: ConversationRunProjection | null;
+    fallbackModelId: string;
+    resolveProvider: (modelId: string) => string;
+    onTerminalState?: (terminalState: HostedLifecycleTerminalState) => Promise<void> | void;
+}
+export interface ConversationHostedTerminalAdapter {
+    toTerminalState: (state: ConversationHostedTerminalStateInput) => HostedLifecycleTerminalState;
+    finalizeRun: (terminalState: HostedLifecycleTerminalState) => Promise<void>;
+    cancelRun: (terminalState: HostedLifecycleTerminalState) => Promise<void>;
+    onTerminalState: (terminalState: HostedLifecycleTerminalState) => Promise<void>;
+    dispatch: (state: ConversationHostedTerminalStateInput) => Promise<HostedLifecycleTerminalState>;
+}
+export declare function toConversationHostedTerminalState(input: {
+    fallbackModelId: string;
+    state: ConversationHostedTerminalStateInput;
+}): HostedLifecycleTerminalState;
+export declare function createConversationHostedTerminalAdapter(options: CreateConversationHostedTerminalAdapterOptions): ConversationHostedTerminalAdapter;
+//# sourceMappingURL=hosted-terminal.d.ts.map

package/esm/src/agent/conversation/hosted-terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-terminal.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/conversation/hosted-terminal.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,yBAAyB,EAE/B,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAE3E,MAAM,WAAW,oCAAoC;IACnD,MAAM,EAAE,4BAA4B,CAAC,QAAQ,CAAC,CAAC;IAC/C,QAAQ,CAAC,EAAE,4BAA4B,CAAC,UAAU,CAAC,CAAC;IACpD,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,eAAO,MAAM,oDAAoD,iBAAiB,CAAC;AACnF,eAAO,MAAM,+CAA+C,YAAY,CAAC;AACzE,eAAO,MAAM,6DAA6D,0BACjD,CAAC;AAM1B,MAAM,WAAW,2CAA2C;IAC1D,SAAS,EAAE,OAAO,CAAC;IACnB,sBAAsB,EAAE,OAAO,CAAC;IAChC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,uCAAuC,CAAC,EAAE,MAAM,CAAC;CAClD;AAED,MAAM,MAAM,yCAAyC,GAAG,IAAI,CAC1D,oCAAoC,EACpC,QAAQ,GAAG,mBAAmB,GAAG,sBAAsB,CACxD,CAAC;AAEF,wBAAgB,sCAAsC,CACpD,KAAK,EAAE,2CAA2C,GACjD,yCAAyC,CAoB3C;AAED,wBAAgB,yCAAyC,CACvD,KAAK,EAAE,OAAO,GACb,yCAAyC,CAM3C;AAED,MAAM,WAAW,wCAAwC;IACvD,QAAQ,EAAE,IAAI,CACZ,iCAAiC,EACjC,iBAAiB,GAAG,aAAa,GAAG,WAAW,GAAG,iBAAiB,CACpE,CAAC;CACH;AAED,wBAAsB,uCAAuC,CAC3D,OAAO,EAAE,wCAAwC,EACjD,KAAK,EAAE,oCAAoC,GAC1C,OAAO,CAAC,4BAA4B,CAAC,CASvC;AAED,wBAAsB,0CAA0C,CAC9D,OAAO,EAAE,wCAAwC,EACjD,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,4BAA4B,CAAC,CAKvC;AAED,MAAM,WAAW,8CAA8C;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,yBAAyB,GAAG,IAAI,CAAC;IACtC,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAC7C,eAAe,CAAC,EAAE,CAAC,aAAa,EAAE,4BAA4B,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACzF;AAED,MAAM,WAAW,iCAAiC;IAChD,eAAe,EAAE,CAAC,KAAK,EAAE,oCAAoC,KAAK,4BAA4B,CAAC;IAC/F,WAAW,EAAE,CAAC,aAAa,EAAE,4BAA4B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5E,SAAS,EAAE,CAAC,aAAa,EAAE,4BAA4B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,eAAe,EAAE,CAAC,aAAa,EAAE,4BAA4B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,QAAQ,EAAE,CAAC,KAAK,EAAE,oCAAoC,KAAK,OAAO,CAAC,4BAA4B,CAAC,CAAC;CAClG;AAqCD,wBAAgB,iCAAiC,CAAC,KAAK,EAAE;IACvD,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,oCAAoC,CAAC;CAC7C,GAAG,4BAA4B,CAqB/B;AAED,wBAAgB,uCAAuC,CACrD,OAAO,EAAE,8CAA8C,GACtD,iCAAiC,CAsDnC"}

package/esm/src/agent/conversation/hosted-terminal.js

@@ -0,0 +1,138 @@
+import { finalizeConversationAgentRun, } from "../durable.js";
+export const CONVERSATION_HOSTED_STREAM_ERROR_TERMINAL_ERROR_CODE = "STREAM_ERROR";
+export const CONVERSATION_HOSTED_ABORTED_TERMINAL_ERROR_CODE = "ABORTED";
+export const CONVERSATION_HOSTED_INCOMPLETE_TOOL_CALLS_TERMINAL_ERROR_CODE = "INCOMPLETE_TOOL_CALLS";
+const DEFAULT_CONVERSATION_HOSTED_ABORTED_TERMINAL_ERROR_MESSAGE = "Chat stream aborted";
+const DEFAULT_CONVERSATION_HOSTED_INCOMPLETE_TOOL_CALLS_TERMINAL_ERROR_MESSAGE = "Assistant completed before tool execution completed";
+export function resolveConversationHostedTerminalState(input) {
+    if (input.isAborted) {
+        return {
+            status: "cancelled",
+            terminalErrorCode: CONVERSATION_HOSTED_ABORTED_TERMINAL_ERROR_CODE,
+            terminalErrorMessage: input.abortedTerminalErrorMessage ??
+                DEFAULT_CONVERSATION_HOSTED_ABORTED_TERMINAL_ERROR_MESSAGE,
+        };
+    }
+    if (input.hasIncompleteToolParts) {
+        return {
+            status: "failed",
+            terminalErrorCode: CONVERSATION_HOSTED_INCOMPLETE_TOOL_CALLS_TERMINAL_ERROR_CODE,
+            terminalErrorMessage: input.incompleteToolCallsTerminalErrorMessage ??
+                DEFAULT_CONVERSATION_HOSTED_INCOMPLETE_TOOL_CALLS_TERMINAL_ERROR_MESSAGE,
+        };
+    }
+    return { status: "completed" };
+}
+export function resolveConversationHostedStreamErrorState(error) {
+    return {
+        status: "failed",
+        terminalErrorCode: CONVERSATION_HOSTED_STREAM_ERROR_TERMINAL_ERROR_CODE,
+        terminalErrorMessage: error instanceof Error ? error.message : String(error),
+    };
+}
+export async function dispatchConversationHostedTerminalState(adapter, state) {
+    const terminalState = adapter.terminal.toTerminalState(state);
+    if (terminalState.status === "cancelled") {
+        await adapter.terminal.cancelRun(terminalState);
+    }
+    else {
+        await adapter.terminal.finalizeRun(terminalState);
+    }
+    await adapter.terminal.onTerminalState(terminalState);
+    return terminalState;
+}
+export async function dispatchConversationHostedStreamErrorState(adapter, error) {
+    return dispatchConversationHostedTerminalState(adapter, resolveConversationHostedStreamErrorState(error));
+}
+function buildConversationHostedLifecycleUsage(usage) {
+    if (!usage) {
+        return undefined;
+    }
+    return {
+        ...(usage.inputTokens !== undefined ? { inputTokens: usage.inputTokens } : {}),
+        ...(usage.outputTokens !== undefined ? { outputTokens: usage.outputTokens } : {}),
+        ...(usage.cachedInputTokens !== undefined
+            ? { cachedInputTokens: usage.cachedInputTokens }
+            : {}),
+    };
+}
+function buildConversationAgentRunUsage(usage) {
+    if (!usage) {
+        return undefined;
+    }
+    const inputTokens = usage.inputTokens ?? 0;
+    const outputTokens = usage.outputTokens ?? 0;
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+    };
+}
+export function toConversationHostedTerminalState(input) {
+    const modelId = input.state.metadata?.modelId ?? input.fallbackModelId;
+    const usage = buildConversationHostedLifecycleUsage(input.state.metadata?.usage);
+    return {
+        status: input.state.status,
+        ...(modelId || usage
+            ? {
+                metadata: {
+                    ...(modelId ? { modelId } : {}),
+                    ...(usage ? { usage } : {}),
+                },
+            }
+            : {}),
+        ...(input.state.terminalErrorCode !== undefined
+            ? { terminalErrorCode: input.state.terminalErrorCode }
+            : {}),
+        ...(input.state.terminalErrorMessage !== undefined
+            ? { terminalErrorMessage: input.state.terminalErrorMessage }
+            : {}),
+    };
+}
+export function createConversationHostedTerminalAdapter(options) {
+    let durableRunFinalized = false;
+    const finalizeDurableRun = async (terminalState, status) => {
+        if (!options.run || durableRunFinalized) {
+            return;
+        }
+        durableRunFinalized = true;
+        const modelId = terminalState.metadata?.modelId ?? options.fallbackModelId;
+        await finalizeConversationAgentRun({
+            authToken: options.authToken,
+            apiUrl: options.apiUrl,
+            conversationId: options.run.conversationId,
+            runId: options.run.runId,
+            status,
+            model: modelId,
+            provider: options.resolveProvider(modelId),
+            usage: buildConversationAgentRunUsage(terminalState.metadata?.usage),
+            terminalErrorCode: terminalState.terminalErrorCode,
+            terminalErrorMessage: terminalState.terminalErrorMessage,
+        });
+    };
+    return {
+        toTerminalState: (state) => toConversationHostedTerminalState({
+            fallbackModelId: options.fallbackModelId,
+            state,
+        }),
+        finalizeRun: (terminalState) => finalizeDurableRun(terminalState, terminalState.status),
+        cancelRun: (terminalState) => finalizeDurableRun(terminalState, "cancelled"),
+        onTerminalState: async (terminalState) => {
+            await options.onTerminalState?.(terminalState);
+        },
+        dispatch: async (state) => {
+            const terminalState = toConversationHostedTerminalState({
+                fallbackModelId: options.fallbackModelId,
+                state,
+            });
+            if (terminalState.status === "cancelled") {
+                await finalizeDurableRun(terminalState, "cancelled");
+            }
+            else {
+                await finalizeDurableRun(terminalState, terminalState.status);
+            }
+            await options.onTerminalState?.(terminalState);
+            return terminalState;
+        },
+    };
+}

package/esm/src/agent/conversation/root-run-context.d.ts

@@ -0,0 +1,57 @@
+import { type ConversationRunProjection } from "../durable.js";
+export interface ConversationRootRunDescriptor {
+    runId: string;
+    messageId: string;
+    latestEventId?: number;
+    latestExternalEventSequence?: number;
+}
+export interface ConversationRootRunContext {
+    run: ConversationRunProjection | null;
+    effectiveParentRunId?: string;
+    effectiveParentMessageId?: string;
+    publishParentRunEvents?: (events: unknown[]) => Promise<void> | void;
+}
+export declare function createConversationRootRunContext(input: {
+    run: ConversationRunProjection | null;
+    parentRunId?: string;
+    parentMessageId?: string;
+    appendParentRunEvents?: ((events: unknown[]) => Promise<void> | void) | undefined;
+}): ConversationRootRunContext;
+export declare function startConversationRootRun(input: {
+    authToken: string;
+    apiUrl: string;
+    conversationId?: string;
+    projectId?: string | null;
+    branchId?: string | null;
+    agentId: string;
+    implementationKind?: string | null;
+    providedRun?: ConversationRootRunDescriptor;
+}): Promise<ConversationRunProjection | null>;
+export declare function createConversationRootRunStartAdapter(input: {
+    authToken: string;
+    apiUrl: string;
+    conversationId?: string;
+    projectId?: string | null;
+    branchId?: string | null;
+    agentId: string;
+    implementationKind?: string | null;
+    providedRun?: ConversationRootRunDescriptor;
+}): (input: {
+    abortSignal: AbortSignal;
+}) => Promise<{
+    run: ConversationRunProjection | null;
+}>;
+export declare function prepareConversationRootRunContext(input: {
+    authToken: string;
+    apiUrl: string;
+    conversationId?: string;
+    projectId?: string | null;
+    branchId?: string | null;
+    agentId: string;
+    implementationKind?: string | null;
+    providedRun?: ConversationRootRunDescriptor;
+    parentRunId?: string;
+    parentMessageId?: string;
+    appendParentRunEvents?: ((events: unknown[]) => Promise<void> | void) | undefined;
+}): Promise<ConversationRootRunContext>;
+//# sourceMappingURL=root-run-context.d.ts.map

package/esm/src/agent/conversation/root-run-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-run-context.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/conversation/root-run-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,yBAAyB,EAA8B,MAAM,eAAe,CAAC;AAE3F,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,yBAAyB,GAAG,IAAI,CAAC;IACtC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,sBAAsB,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACtE;AAwBD,wBAAgB,gCAAgC,CAAC,KAAK,EAAE;IACtD,GAAG,EAAE,yBAAyB,GAAG,IAAI,CAAC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;CACnF,GAAG,0BAA0B,CAO7B;AAED,wBAAsB,wBAAwB,CAAC,KAAK,EAAE;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,WAAW,CAAC,EAAE,6BAA6B,CAAC;CAC7C,GAAG,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC,CAyB5C;AAED,wBAAgB,qCAAqC,CAAC,KAAK,EAAE;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,WAAW,CAAC,EAAE,6BAA6B,CAAC;CAC7C,GAAG,CAAC,KAAK,EAAE;IAAE,WAAW,EAAE,WAAW,CAAA;CAAE,KAAK,OAAO,CAAC;IAAE,GAAG,EAAE,yBAAyB,GAAG,IAAI,CAAA;CAAE,CAAC,CAa9F;AAED,wBAAsB,iCAAiC,CAAC,KAAK,EAAE;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,WAAW,CAAC,EAAE,6BAA6B,CAAC;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;CACnF,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAkBtC"}