@truefoundry/trueforge-assistant-ui-runtime 0.0.0 → 0.2.0-rc.0

package/dist/index.d.ts

@@ -0,0 +1,378 @@
+import * as _assistant_ui_core from '@assistant-ui/core';
+import { AttachmentAdapter, ThreadAssistantMessagePart, ThreadMessage, AppendMessage, ExportedMessageRepositoryItem, RemoteThreadListAdapter, ExternalStoreSharedOptions, SpeechSynthesisAdapter, DictationAdapter, RealtimeVoiceAdapter, FeedbackAdapter } from '@assistant-ui/core';
+import { TurnEvent, ThreadCreatedEvent, UserToolResponseEvent, McpAuthRequiredEvent, UserToolApprovalEvent, Turn, TurnInputItem, AgentChatServer, AgentSpec, Session } from './server/index.js';
+export { AgentBuilderCapabilitiesResponse, AgentBuilderServer, AgentCapabilityConfig, AgentCompactionConfig, AgentContextManagementConfig, AgentDetail, AgentInputTokensCompactionTrigger, AgentLibraryEntry, AgentMetricChartData, AgentMetricChartDataRequest, AgentMetricChartDefinition, AgentMetricChartType, AgentMetricGraph, AgentMetricGraphLine, AgentMetricMeter, AgentMetricPoint, AgentMetricRangeRequest, AgentMetricsServer, AgentRuntimeConfig, AgentSandboxConfig, AgentSelectorEntry, AgentSessionsServer, AgentSkill, AgentUIServer, AgentUIServerPort, ApprovalDecision, AuthenticateConnectorRequest, CatalogServer, CodeSnippet, CodeSnippetSampleCode, ConnectorAuth, ConnectorAuthApiKey, ConnectorAuthNone, ConnectorAuthOAuth, ConnectorAuthPublic, ConnectorAuthPublicApiKey, ConnectorAuthPublicNone, ConnectorAuthPublicOAuth, ConnectorAuthType, ConnectorAuthenticationResult, ConnectorBase, ConnectorCatalogEntry, ConnectorCatalogServer, ConnectorConfigBase, ConnectorSelectorEntry, ConnectorState, CreateConnectorRequest, CreateModelProviderRequest, CreateSandboxProviderRequest, CreateSandboxRequest, CreateScheduleRequest, CreateScheduleRunRequest, CreateSessionRequest, CreateSkillRequest, CreateSkillRequestBase, CreateWebSearchProviderRequest, CreateWebSearchRequest, CreatedBySubject, DefinedSkill, GithubSkill, ImportGithubSkillRequest, ListPermissionsRequest, ListPermissionsResponse, ListResult, ListSchedulesParams, ListSessionEventsParams, ListSessionsOrder, ListSessionsParams, McpServerMount, McpToolSelection, Model, ModelCatalogServer, ModelEntry, ModelMessageEvent, ModelParams, ModelProperties, ModelProviderBase, ModelProviderCatalogEntry, ModelProviderConfigBase, ModelSelection, ModelSelectorEntry, PageParams, PermissionResourceType, PermissionsServer, PreviousTurnIdInput, ProviderEntry, ProviderType, RegistrySkill, ResourcePermission, SandboxBase, SandboxCatalogEntry, SandboxCatalogServer, SandboxConfig, SandboxCreatedEvent, SandboxProviderBase, SandboxProviderCatalogEntry, SandboxProviderConfig, SandboxProviderListEntry, SandboxSnapshotSyncStatus, SaveAgentRequest, SaveAgentResult, Schedule, ScheduleRun, ScheduleRunStatus, ScheduleServer, ScheduleStatus, SearchAgentSelectorParams, SearchAgentsParams, SelectRegistrySkillRequest, SessionEventItem, SessionListEntry, SessionListMetrics, SkillBase, SkillCatalogEntry, SkillCatalogServer, SkillConfigBase, SkillMount, SkillSelectorEntry, ToolApprovalRequiredEvent, ToolBase, ToolCall, ToolResponseRequiredEvent, TurnDoneMetrics, TurnState, TurnStateDone, TurnStreamData, TurnStreamingEvent, UpdateConnectorRequest, UpdateModelProviderRequest, UpdateSandboxProviderRequest, UpdateSandboxRequest, UpdateScheduleRequest, UpdateSessionRequest, UpdateWebSearchProviderRequest, UpdateWebSearchRequest, UserMessage, WebSearchBase, WebSearchCatalogEntry, WebSearchCatalogServer, WebSearchProviderBase, WebSearchProviderCatalogEntry, isEventDelta, mergeEventDelta } from './server/index.js';
+import { AssistantClient } from '@assistant-ui/store';
+
+/**
+ * Reads composer files into `CompleteAttachment` `file` parts for send.
+ * Wire via `adapters: { attachments: trueForgeAttachmentAdapter }`.
+ */
+declare const trueForgeAttachmentAdapter: AttachmentAdapter;
+
+interface PendingApproval {
+    approvalId: string;
+    threadId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    argsText: string;
+}
+interface PendingToolResponse {
+    toolCallId: string;
+    threadId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    argsText: string;
+    question?: string;
+    options?: string[];
+}
+
+/** Gateway root thread id — always the literal `"main"`. */
+declare const ROOT_THREAD_ID = "main";
+
+type AssistantContentPart = ThreadAssistantMessagePart;
+
+type AgentInfo = ThreadCreatedEvent['agentInfo'];
+interface SubAgentCustomMetadata {
+    threadId: string;
+    title?: string;
+    name?: string;
+    model?: string;
+    input?: string;
+}
+interface SubAgentArtifact {
+    subAgents: {
+        threadId: string;
+        title?: string;
+        agentInfo?: AgentInfo;
+    }[];
+}
+interface PendingResponseRef {
+    id: string;
+    sourceEventId: string;
+    question?: string;
+    options?: string[];
+}
+interface ApprovalDecisionRef {
+    id: string;
+    approved: boolean;
+    reason?: string;
+}
+interface ThreadBucket {
+    events: Map<string, TurnEvent>;
+    modelMessageIds: string[];
+    toolResults: Map<string, string>;
+    pendingApprovals: Map<string, {
+        id: string;
+    }>;
+    approvalDecisions: Map<string, ApprovalDecisionRef>;
+    pendingResponses: Map<string, PendingResponseRef>;
+    done: boolean;
+    title?: string;
+    agentInfo?: AgentInfo;
+}
+interface ThreadParentLink {
+    parentThreadId: string;
+    toolCallId: string;
+}
+declare class PeerThreadFoldState {
+    readonly threads: Map<string, ThreadBucket>;
+    readonly threadParents: Map<string, ThreadParentLink>;
+    getOrCreateBucket(threadId: string): ThreadBucket;
+}
+
+declare const TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY = "toolResponseThreadId";
+type RespondToToolResponseOptions = Pick<UserToolResponseEvent, 'toolCallId' | 'content'>;
+declare function messageHasPendingResponses(message: ThreadMessage | undefined): boolean;
+declare function collectResponseInputs(message: ThreadMessage, threadId: string): UserToolResponseEvent[];
+
+/** Keys written to `ThreadMessage.metadata.custom` by this runtime adapter. */
+interface TrueForgeMessageCustomMetadata {
+    subAgent?: SubAgentCustomMetadata;
+    pendingMcpAuth?: true;
+    mcpServers?: McpAuthRequiredEvent['mcpServers'];
+    sandboxId?: string;
+    /** Turn that produced this message. Scopes artifact downloads to their own turn. */
+    turnId?: string;
+    [TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY]?: string;
+    [TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY]?: string;
+}
+type SubAgentMessageCustomMetadata = Pick<TrueForgeMessageCustomMetadata, 'subAgent'>;
+type McpAuthMessageCustomMetadata = Pick<TrueForgeMessageCustomMetadata, 'pendingMcpAuth' | 'mcpServers'>;
+type SandboxMessageCustomMetadata = Pick<TrueForgeMessageCustomMetadata, 'sandboxId'>;
+type ToolApprovalMessageCustomMetadata = Pick<TrueForgeMessageCustomMetadata, typeof TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY>;
+type ToolResponseMessageCustomMetadata = Pick<TrueForgeMessageCustomMetadata, typeof TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY>;
+
+declare const TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY = "toolApprovalThreadId";
+interface RespondToToolApprovalOptions {
+    approvalId: string;
+    approved: boolean;
+    optionId?: string;
+    reason?: string;
+}
+declare function messageHasPendingApprovals(message: ThreadMessage | undefined): boolean;
+declare function collectApprovalInputs(message: ThreadMessage, threadId: string): UserToolApprovalEvent[];
+declare function toTrueForgeApprovalInputs(message: Extract<ThreadMessage, {
+    role: 'assistant';
+}>, response: RespondToToolApprovalOptions, defaultThreadId?: string): UserToolApprovalEvent[];
+
+interface ConvertTurnsResult {
+    messages: ThreadMessage[];
+    foldState: PeerThreadFoldState;
+    runningTurn?: Turn;
+    unstable_resume?: boolean;
+}
+declare function buildTurnAssistantContent(server: AgentChatServer, sessionId: string, turn: Pick<Turn, 'id' | 'state'>, foldState?: PeerThreadFoldState): Promise<AssistantContentPart[]>;
+declare function convertTurnsToThreadMessages(server: AgentChatServer, sessionId: string): Promise<ConvertTurnsResult>;
+declare function getTurnMessageContent(message: AppendMessage): string;
+/**
+ * Gateway `user.message` content (string for text-only, or text/file parts).
+ * Derived from SDK `TurnInputItem` so it tracks API changes.
+ */
+type UserMessageContent = Extract<TurnInputItem, {
+    type: 'user.message';
+}>['content'];
+/**
+ * Builds the gateway turn input content from a composer message, forwarding
+ * attachments as SDK `FileContent` parts. Mirrors how assistant-ui surfaces
+ * attachment content on `message.attachments[].content`.
+ */
+declare function buildUserMessageContent(message: AppendMessage): UserMessageContent;
+/** Strips the `-user` suffix from a projected user message id to recover the turn id. */
+declare function parseTurnIdFromMessageId(messageId: string): string;
+/**
+ * Builds resubmit content for a text-only edit: replaces text with `editedText`
+ * while preserving original file parts from the turn record.
+ */
+declare function buildEditedUserMessageContent(editedText: string, originalInput: TurnInputItem[] | undefined): UserMessageContent;
+declare function repositoryItemsFromMessages(messages: readonly ThreadMessage[]): ExportedMessageRepositoryItem[];
+
+interface DraftSession {
+    title?: string | null;
+    agentSpec: AgentSpec;
+}
+/** Partial update — host fields flow through when `TSpec` is widened. */
+type AgentSpecUpdate<TSpec extends AgentSpec = AgentSpec> = {
+    [K in keyof TSpec]?: K extends 'model' ? Omit<Partial<TSpec['model']>, 'params'> & {
+        params?: Partial<NonNullable<TSpec['model']['params']>>;
+    } : TSpec[K];
+};
+declare function mergeAgentSpec<TSpec extends AgentSpec>(base: TSpec, update: AgentSpecUpdate<TSpec>): TSpec;
+declare function draftSessionTitle(draft: DraftSession): string;
+
+interface DraftSessionBridge {
+    syncAgentSpec: (draftSessionId: string, agentSpec: AgentSpec) => Promise<string>;
+    getDraftAgentSpec: (draftSessionId: string) => Promise<AgentSpec>;
+}
+declare function createDraftSessionBridge(server: AgentChatServer): DraftSessionBridge;
+
+declare function createTrueForgeDraftThreadListAdapter(options: {
+    server: AgentChatServer;
+    defaultAgentSpec: AgentSpec;
+    getAgentSpec?: () => AgentSpec;
+    /** When set, filters `listSessions` by this agent id. Omit for all chats. */
+    listSessionsAgentId?: string;
+    /** Restrict history to sessions created by the authenticated subject. */
+    listSessionsCreatedByMe?: boolean;
+}): RemoteThreadListAdapter;
+
+interface TrueForgeDraftRuntimeExtras {
+    agentSpec: AgentSpec | null;
+    draftSessionId: string | undefined;
+    isSpecLoading: boolean;
+    isSpecSyncing: boolean;
+    specError: unknown;
+    updateAgentSpec: (update: AgentSpecUpdate) => void;
+    flushAgentSpec: () => Promise<void>;
+    adoptAgentSpec: (request: {
+        agentSpec: AgentSpec;
+        updatedAt?: string;
+    }) => void;
+}
+interface TrueForgeRuntimeExtras {
+    pendingApprovals: PendingApproval[];
+    pendingToolResponses: PendingToolResponse[];
+    pendingMcpAuth: {
+        mcpServers: McpAuthRequiredEvent['mcpServers'];
+    } | null;
+    resumeUnavailable: boolean;
+    sandboxId: string | undefined;
+    respondToToolApproval: (response: RespondToToolApprovalOptions) => void;
+    respondToToolResponse: (response: RespondToToolResponseOptions) => void;
+    resumeMcpAuth: () => Promise<void>;
+    downloadSandboxFile: (req: {
+        turnId: string;
+        path: string;
+    }) => Promise<Blob>;
+    cancel: () => Promise<void>;
+    resetFromTurn: (turnId: string) => Promise<void>;
+    reload: () => void;
+    hasOlderHistory: boolean;
+    isLoadingOlderHistory: boolean;
+    loadOlderHistory: () => Promise<void>;
+    draft: TrueForgeDraftRuntimeExtras | null;
+}
+/**
+ * `PartPrimitive.Messages` wraps sub-agent threads in `ReadonlyThreadProvider`,
+ * which shadows `thread` (and therefore `thread.extras`) with a readonly client
+ * that has no TrueForge extras. Nested AUI clients are `Object.create(parent)`,
+ * so walk the prototype chain to reach the root runtime extras.
+ */
+declare function tryGetTrueForgeExtras(client: AssistantClient): TrueForgeRuntimeExtras | undefined;
+declare function getTrueForgeExtras(client: AssistantClient): TrueForgeRuntimeExtras;
+declare function useTrueForgeExtrasApi(): TrueForgeRuntimeExtras;
+declare function useTrueForgeExtrasApi<S>(select: (extras: TrueForgeRuntimeExtras) => S, fallback?: S): S;
+/**
+ * Brand + provide/tryGet from assistant-ui; get/use walk ancestor AUI clients so
+ * nested readonly sub-agent threads still resolve root TrueForge extras.
+ */
+declare const trueForgeExtras: {
+    provide: (value: TrueForgeRuntimeExtras) => TrueForgeRuntimeExtras;
+    is: (extras: unknown) => extras is TrueForgeRuntimeExtras;
+    tryGet: (extras: unknown) => TrueForgeRuntimeExtras | undefined;
+    get: typeof getTrueForgeExtras;
+    use: typeof useTrueForgeExtrasApi;
+};
+
+/** Pending tool approvals plus a respond action. */
+declare const useTrueForgeApprovals: () => {
+    pending: PendingApproval[];
+    respond: (response: RespondToToolApprovalOptions) => void;
+};
+/** Pending ask-user tool responses plus a respond action. */
+declare const useTrueForgeToolResponses: () => {
+    pending: PendingToolResponse[];
+    respond: (response: RespondToToolResponseOptions) => void;
+};
+/** Pending MCP OAuth plus a resume action. */
+declare const useTrueForgeMcpAuth: () => {
+    pending: {
+        mcpServers: McpAuthRequiredEvent["mcpServers"];
+    } | null;
+    resume: () => Promise<void>;
+};
+/** Returns a function to respond to a tool approval from any render context. */
+declare const useTrueForgeRespondToToolApproval: () => (response: RespondToToolApprovalOptions) => void;
+/** Returns a function to respond to a pending tool response from any render context. */
+declare const useTrueForgeRespondToToolResponse: () => (response: RespondToToolResponseOptions) => void;
+/** Returns a function to resume after MCP OAuth from any render context. */
+declare const useTrueForgeResumeMcpAuth: () => () => Promise<void>;
+/** Current sandboxId for this session, if a sandbox has been created. */
+declare const useTrueForgeSandboxId: () => string | undefined;
+/** Turn that produced the message being rendered. Only defined inside a message scope. */
+declare const useTrueForgeTurnId: () => string | undefined;
+/**
+ * Returns a function to download a file the current turn wrote to its sandbox. Must be called
+ * from a message scope, since the artifact belongs to the turn that rendered it.
+ * Does not require extras `sandboxId` — turn-scoped hosts resolve the sandbox from `turnId`.
+ */
+declare const useTrueForgeDownloadSandboxFile: () => (path: string) => Promise<Blob>;
+/** Returns a function to cancel the current run from any render context. */
+declare const useTrueForgeCancel: () => () => Promise<void>;
+/** Returns a function to reload (retry) the current session from any render context. */
+declare const useTrueForgeReload: () => () => void;
+/** Older history pagination state plus a load-more action for scroll-up. */
+declare const useTrueForgeHistoryPagination: () => {
+    hasOlderHistory: boolean;
+    isLoadingOlderHistory: boolean;
+    loadOlderHistory: () => Promise<void>;
+};
+/**
+ * True while a turn runs that this server cannot stream, so its result will not
+ * arrive in this client. Falls back to `false` on runtimes that predate the flag.
+ */
+declare const useTrueForgeResumeUnavailable: () => boolean;
+/** Returns a function to reset (re-submit) a user turn from any render context. */
+declare const useTrueForgeResetFromTurn: () => (turnId: string) => Promise<void>;
+/** Current draft agent spec and sync state (draft mode only). */
+declare const useTrueForgeAgentSpec: () => {
+    agentSpec: AgentSpec | null;
+    draftSessionId: string | undefined;
+    isSpecLoading: boolean;
+    isSpecSyncing: boolean;
+    specError: unknown;
+    updateAgentSpec: (update: AgentSpecUpdate) => void;
+    flushAgentSpec: () => Promise<void>;
+    adoptAgentSpec: (request: {
+        agentSpec: AgentSpec;
+        updatedAt?: string;
+    }) => void;
+};
+/** Returns a draft spec updater from any render context. */
+declare const useTrueForgeUpdateAgentSpec: () => (update: Parameters<TrueForgeDraftRuntimeExtras["updateAgentSpec"]>[0]) => void | undefined;
+/** Flushes any pending draft-spec synchronization before a coordinated write. */
+declare const useTrueForgeFlushAgentSpec: () => () => Promise<void>;
+/** Adopts a spec already persisted by another server operation without syncing again. */
+declare const useTrueForgeAdoptAgentSpec: () => (request: Parameters<TrueForgeDraftRuntimeExtras["adoptAgentSpec"]>[0]) => void | undefined;
+
+type RequiredActionInput = Extract<TurnInputItem, UserToolApprovalEvent | UserToolResponseEvent>;
+declare function messageHasPendingRequiredActions(message: ThreadMessage | undefined): boolean;
+declare function collectRequiredActionInputs(message: ThreadMessage, defaultThreadId?: string): RequiredActionInput[];
+declare function findPausedAssistantMessage(messages: readonly ThreadMessage[]): Extract<ThreadMessage, {
+    role: 'assistant';
+}> | undefined;
+
+/** `sessionId` is the assistant-ui thread `remoteId` from `RemoteThreadListAdapter.initialize`. */
+declare function getSession(server: AgentChatServer, sessionId: string): Promise<Session>;
+
+/**
+ * Read-only thread-list adapter backed by `AgentChatServer.listSessions`.
+ */
+declare function createTrueForgeOwnedSessionsThreadListAdapter(options: {
+    server: AgentChatServer;
+    /** When set, filters `listSessions` by this agent id. Omit for all chats. */
+    listSessionsAgentId?: string;
+    /** Restrict history to sessions created by the authenticated subject. */
+    listSessionsCreatedByMe?: boolean;
+}): RemoteThreadListAdapter;
+
+declare function createTrueForgeThreadListAdapter(options: {
+    server: AgentChatServer;
+    agentName: string;
+    /** When set, filters `listSessions` by this agent id. Omit for all chats. */
+    listSessionsAgentId?: string;
+    /** Restrict history to sessions created by the authenticated subject. */
+    listSessionsCreatedByMe?: boolean;
+}): RemoteThreadListAdapter;
+
+interface NamedAgentConfig {
+    mode: 'named';
+    agentName: string;
+}
+interface DraftAgentConfig {
+    mode: 'draft';
+    defaultAgentSpec: AgentSpec;
+    onAgentSpecChange?: ((spec: AgentSpec) => void) | undefined;
+}
+type TrueForgeAgentConfig = NamedAgentConfig | DraftAgentConfig;
+type TrueForgeAgentRuntimeBaseOptions = ExternalStoreSharedOptions & {
+    server: AgentChatServer;
+    initialSessionId?: string | undefined;
+    threadId?: string | undefined;
+    onThreadIdChange?: ((threadId: string | undefined) => void) | undefined;
+    onError?: ((error: unknown) => void) | undefined;
+    /**
+     * Optional filter forwarded to `listSessions({ agentId })`.
+     * Omit for all chats; hosts that key agents by name pass that name as the id.
+     */
+    listSessionsAgentId?: string | undefined;
+    /** Restrict thread history to sessions created by the authenticated subject. */
+    listSessionsCreatedByMe?: boolean | undefined;
+    adapters?: {
+        attachments?: AttachmentAdapter | undefined;
+        speech?: SpeechSynthesisAdapter | undefined;
+        dictation?: DictationAdapter | undefined;
+        voice?: RealtimeVoiceAdapter | undefined;
+        feedback?: FeedbackAdapter | undefined;
+    } | undefined;
+};
+type UseTrueForgeAgentRuntimeOptions = TrueForgeAgentRuntimeBaseOptions & {
+    /** Discriminated agent source. Omit when using legacy `agentName`. */
+    agent?: TrueForgeAgentConfig | undefined;
+    /** Legacy named-agent shorthand. Prefer `agent: { mode: "named", agentName }`. */
+    agentName?: string | undefined;
+};
+
+declare function useTrueForgeAgentRuntime(options: UseTrueForgeAgentRuntimeOptions): _assistant_ui_core.AssistantRuntime;
+
+export { AgentChatServer, AgentSpec, type AgentSpecUpdate, type ConvertTurnsResult, type DraftAgentConfig, type DraftSession, type DraftSessionBridge, type McpAuthMessageCustomMetadata, McpAuthRequiredEvent, type NamedAgentConfig, type PendingApproval, type PendingToolResponse, ROOT_THREAD_ID, type SandboxMessageCustomMetadata, Session, type SubAgentArtifact, type SubAgentCustomMetadata, type SubAgentMessageCustomMetadata, TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY, ThreadCreatedEvent, type ToolApprovalMessageCustomMetadata, type ToolResponseMessageCustomMetadata, type TrueForgeAgentConfig, type TrueForgeDraftRuntimeExtras, type TrueForgeMessageCustomMetadata, type TrueForgeRuntimeExtras, Turn, TurnEvent, TurnInputItem, type UseTrueForgeAgentRuntimeOptions, type UserMessageContent, UserToolApprovalEvent, UserToolResponseEvent, buildEditedUserMessageContent, buildTurnAssistantContent, buildUserMessageContent, collectApprovalInputs, collectRequiredActionInputs, collectResponseInputs, convertTurnsToThreadMessages, createDraftSessionBridge, createTrueForgeDraftThreadListAdapter, createTrueForgeOwnedSessionsThreadListAdapter, createTrueForgeThreadListAdapter, draftSessionTitle, findPausedAssistantMessage, getSession, getTrueForgeExtras, getTurnMessageContent, mergeAgentSpec, messageHasPendingApprovals, messageHasPendingRequiredActions, messageHasPendingResponses, parseTurnIdFromMessageId, repositoryItemsFromMessages, toTrueForgeApprovalInputs, trueForgeAttachmentAdapter, trueForgeExtras, tryGetTrueForgeExtras, useTrueForgeAdoptAgentSpec, useTrueForgeAgentRuntime, useTrueForgeAgentSpec, useTrueForgeApprovals, useTrueForgeCancel, useTrueForgeDownloadSandboxFile, useTrueForgeFlushAgentSpec, useTrueForgeHistoryPagination, useTrueForgeMcpAuth, useTrueForgeReload, useTrueForgeResetFromTurn, useTrueForgeRespondToToolApproval, useTrueForgeRespondToToolResponse, useTrueForgeResumeMcpAuth, useTrueForgeResumeUnavailable, useTrueForgeSandboxId, useTrueForgeToolResponses, useTrueForgeTurnId, useTrueForgeUpdateAgentSpec };