@assistant-ui/react-ag-ui 0.0.44 → 0.0.46

package/dist/agUiExtras.d.ts

@@ -1,5 +1,4 @@
 import { AgUiRuntimeExtras } from "./runtime/types.js";
-
 //#region src/agUiExtras.d.ts
 declare const agUiExtras: import("@assistant-ui/core/internal").RuntimeExtras<AgUiRuntimeExtras>;
 //#endregion

package/dist/agUiExtras.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agUiExtras.d.ts","names":[],"sources":["../src/agUiExtras.ts"],"mappings":";;;cAGa,UAAA,wCAAU,aAAA,CAAA,iBAAA"}
+{"version":3,"file":"agUiExtras.d.ts","names":[],"sources":["../src/agUiExtras.ts"],"mappings":";;cAGa,kDAAU,cAAA"}

package/dist/hooks.d.ts

@@ -1,6 +1,6 @@
 import { AgUiInterrupt, AgUiResumeEntry } from "./runtime/types.js";
 import { CreateAppendMessage } from "@assistant-ui/core";
-
+import { ReadonlyJSONValue } from "assistant-stream/utils";
 //#region src/hooks.d.ts
 /**
  * Read the pending AG-UI interrupts on the current thread. Returns an empty
@@ -13,15 +13,21 @@ declare const useAgUiInterrupts: () => readonly AgUiInterrupt[];
  */
 declare const useAgUiSubmitInterruptResponses: () => (responses: readonly AgUiResumeEntry[]) => Promise<void>;
 /**
- * Returns a function that discards the pending AG-UI interrupts and appends the
- * given user message, starting a fresh run. Use this when the user sends a new
- * message instead of resolving the interrupt(s): every open interrupt is
- * reported to the agent as cancelled. The message accepts a plain string or a
- * partial `AppendMessage` (the parent defaults to the current head). Pass
- * `responses` to override the status of specific interrupts; the rest still
- * default to cancelled.
+ * Returns a function that discards the pending AG-UI interrupts or pending
+ * client-side tool calls and appends the given user message, starting a fresh
+ * run. Use this when the user sends a new message instead of resolving them:
+ * every open interrupt is reported to the agent as cancelled, and every
+ * unresolved client-side tool call receives an error result. The message
+ * accepts a plain string or a partial `AppendMessage` (the parent defaults to
+ * the current head). Pass `responses` to override the status of specific
+ * interrupts; the rest still default to cancelled. `responses` throws when
+ * tool calls rather than interrupts are pending. Unlike the
+ * `autoCancelPendingToolCalls` runtime option, this hook cancels regardless
+ * of that option's value.
  */
 declare const useAgUiSteerAway: () => (message: CreateAppendMessage, responses?: readonly AgUiResumeEntry[]) => Promise<void>;
+declare const useAgUiState: <TState = ReadonlyJSONValue>() => TState | undefined;
+declare const useAgUiSetState: <TState = ReadonlyJSONValue>() => (next: TState | ((prev: TState | undefined) => TState)) => void;
 //#endregion
-export { useAgUiInterrupts, useAgUiSteerAway, useAgUiSubmitInterruptResponses };
+export { useAgUiInterrupts, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };
 //# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","names":[],"sources":["../src/hooks.ts"],"mappings":";;;;;;AAaA;;cAAa,iBAAA,iBAAiC,aAAa;;AAAA;AAO3D;;cAAa,+BAAA,SAEH,SAAA,WAAoB,eAAA,OAAoB,OAAO;;;;;;AAAA;AAazD;;;cAAa,gBAAA,SAGT,OAAA,EAAS,mBAAA,EACT,SAAA,YAAqB,eAAA,OACpB,OAAA"}
+{"version":3,"file":"hooks.d.ts","names":[],"sources":["../src/hooks.ts"],"mappings":";;;;;;;;cAca,kCAAiC;;;;;cAOjC,wCAEH,oBAAoB,sBAAoB;;;;;;;;;;;;;;cAiBrC,yBAGT,SAAS,qBACT,qBAAqB,sBACpB;cAGQ,eAAgB,SAAS,wBAClC;cAIS,kBAAmB,SAAS,yBAE/B,MAAM,WAAW,MAAM,uBAAuB"}

package/dist/hooks.js

@@ -17,19 +17,28 @@ const useAgUiSubmitInterruptResponses = () => {
 	return (responses) => agUiExtras.get(aui).submitInterruptResponses(responses);
 };
 /**
-* Returns a function that discards the pending AG-UI interrupts and appends the
-* given user message, starting a fresh run. Use this when the user sends a new
-* message instead of resolving the interrupt(s): every open interrupt is
-* reported to the agent as cancelled. The message accepts a plain string or a
-* partial `AppendMessage` (the parent defaults to the current head). Pass
-* `responses` to override the status of specific interrupts; the rest still
-* default to cancelled.
+* Returns a function that discards the pending AG-UI interrupts or pending
+* client-side tool calls and appends the given user message, starting a fresh
+* run. Use this when the user sends a new message instead of resolving them:
+* every open interrupt is reported to the agent as cancelled, and every
+* unresolved client-side tool call receives an error result. The message
+* accepts a plain string or a partial `AppendMessage` (the parent defaults to
+* the current head). Pass `responses` to override the status of specific
+* interrupts; the rest still default to cancelled. `responses` throws when
+* tool calls rather than interrupts are pending. Unlike the
+* `autoCancelPendingToolCalls` runtime option, this hook cancels regardless
+* of that option's value.
 */
 const useAgUiSteerAway = () => {
 	const aui = useAui();
 	return (message, responses) => agUiExtras.get(aui).steerAway(message, responses);
 };
+const useAgUiState = () => agUiExtras.use((e) => e.state, void 0);
+const useAgUiSetState = () => {
+	const aui = useAui();
+	return (next) => agUiExtras.get(aui).setState(next);
+};
 //#endregion
-export { useAgUiInterrupts, useAgUiSteerAway, useAgUiSubmitInterruptResponses };
+export { useAgUiInterrupts, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };
 
 //# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.js","names":[],"sources":["../src/hooks.ts"],"sourcesContent":["\"use client\";\n\nimport { useAui } from \"@assistant-ui/store\";\nimport type { CreateAppendMessage } from \"@assistant-ui/core\";\nimport { agUiExtras } from \"./agUiExtras\";\nimport type { AgUiInterrupt, AgUiResumeEntry } from \"./runtime/types\";\n\nconst EMPTY_INTERRUPTS: readonly AgUiInterrupt[] = [];\n\n/**\n * Read the pending AG-UI interrupts on the current thread. Returns an empty\n * array when no interrupts are pending, so consumers can `.map` without a guard.\n */\nexport const useAgUiInterrupts = (): readonly AgUiInterrupt[] =>\n  agUiExtras.use((e) => e.interrupts, EMPTY_INTERRUPTS);\n\n/**\n * Returns a function that submits responses (each `resolved` or `cancelled`)\n * for the pending AG-UI interrupts and resumes the run.\n */\nexport const useAgUiSubmitInterruptResponses = () => {\n  const aui = useAui();\n  return (responses: readonly AgUiResumeEntry[]): Promise<void> =>\n    agUiExtras.get(aui).submitInterruptResponses(responses);\n};\n\n/**\n * Returns a function that discards the pending AG-UI interrupts and appends the\n * given user message, starting a fresh run. Use this when the user sends a new\n * message instead of resolving the interrupt(s): every open interrupt is\n * reported to the agent as cancelled. The message accepts a plain string or a\n * partial `AppendMessage` (the parent defaults to the current head). Pass\n * `responses` to override the status of specific interrupts; the rest still\n * default to cancelled.\n */\nexport const useAgUiSteerAway = () => {\n  const aui = useAui();\n  return (\n    message: CreateAppendMessage,\n    responses?: readonly AgUiResumeEntry[],\n  ): Promise<void> => agUiExtras.get(aui).steerAway(message, responses);\n};\n"],"mappings":";;;;AAOA,MAAM,mBAA6C,CAAC;;;;;AAMpD,MAAa,0BACX,WAAW,KAAK,MAAM,EAAE,YAAY,gBAAgB;;;;;AAMtD,MAAa,wCAAwC;CACnD,MAAM,MAAM,OAAO;CACnB,QAAQ,cACN,WAAW,IAAI,GAAG,CAAC,CAAC,yBAAyB,SAAS;AAC1D;;;;;;;;;;AAWA,MAAa,yBAAyB;CACpC,MAAM,MAAM,OAAO;CACnB,QACE,SACA,cACkB,WAAW,IAAI,GAAG,CAAC,CAAC,UAAU,SAAS,SAAS;AACtE"}
+{"version":3,"file":"hooks.js","names":[],"sources":["../src/hooks.ts"],"sourcesContent":["\"use client\";\n\nimport { useAui } from \"@assistant-ui/store\";\nimport type { CreateAppendMessage } from \"@assistant-ui/core\";\nimport type { ReadonlyJSONValue } from \"assistant-stream/utils\";\nimport { agUiExtras } from \"./agUiExtras\";\nimport type { AgUiInterrupt, AgUiResumeEntry } from \"./runtime/types\";\n\nconst EMPTY_INTERRUPTS: readonly AgUiInterrupt[] = [];\n\n/**\n * Read the pending AG-UI interrupts on the current thread. Returns an empty\n * array when no interrupts are pending, so consumers can `.map` without a guard.\n */\nexport const useAgUiInterrupts = (): readonly AgUiInterrupt[] =>\n  agUiExtras.use((e) => e.interrupts, EMPTY_INTERRUPTS);\n\n/**\n * Returns a function that submits responses (each `resolved` or `cancelled`)\n * for the pending AG-UI interrupts and resumes the run.\n */\nexport const useAgUiSubmitInterruptResponses = () => {\n  const aui = useAui();\n  return (responses: readonly AgUiResumeEntry[]): Promise<void> =>\n    agUiExtras.get(aui).submitInterruptResponses(responses);\n};\n\n/**\n * Returns a function that discards the pending AG-UI interrupts or pending\n * client-side tool calls and appends the given user message, starting a fresh\n * run. Use this when the user sends a new message instead of resolving them:\n * every open interrupt is reported to the agent as cancelled, and every\n * unresolved client-side tool call receives an error result. The message\n * accepts a plain string or a partial `AppendMessage` (the parent defaults to\n * the current head). Pass `responses` to override the status of specific\n * interrupts; the rest still default to cancelled. `responses` throws when\n * tool calls rather than interrupts are pending. Unlike the\n * `autoCancelPendingToolCalls` runtime option, this hook cancels regardless\n * of that option's value.\n */\nexport const useAgUiSteerAway = () => {\n  const aui = useAui();\n  return (\n    message: CreateAppendMessage,\n    responses?: readonly AgUiResumeEntry[],\n  ): Promise<void> => agUiExtras.get(aui).steerAway(message, responses);\n};\n\nexport const useAgUiState = <TState = ReadonlyJSONValue>():\n  | TState\n  | undefined =>\n  agUiExtras.use((e) => e.state as TState | undefined, undefined);\n\nexport const useAgUiSetState = <TState = ReadonlyJSONValue>() => {\n  const aui = useAui();\n  return (next: TState | ((prev: TState | undefined) => TState)): void =>\n    agUiExtras\n      .get(aui)\n      .setState(\n        next as\n          | ReadonlyJSONValue\n          | ((prev: ReadonlyJSONValue | undefined) => ReadonlyJSONValue),\n      );\n};\n"],"mappings":";;;;AAQA,MAAM,mBAA6C,CAAC;;;;;AAMpD,MAAa,0BACX,WAAW,KAAK,MAAM,EAAE,YAAY,gBAAgB;;;;;AAMtD,MAAa,wCAAwC;CACnD,MAAM,MAAM,OAAO;CACnB,QAAQ,cACN,WAAW,IAAI,GAAG,CAAC,CAAC,yBAAyB,SAAS;AAC1D;;;;;;;;;;;;;;AAeA,MAAa,yBAAyB;CACpC,MAAM,MAAM,OAAO;CACnB,QACE,SACA,cACkB,WAAW,IAAI,GAAG,CAAC,CAAC,UAAU,SAAS,SAAS;AACtE;AAEA,MAAa,qBAGX,WAAW,KAAK,MAAM,EAAE,OAA6B,KAAA,CAAS;AAEhE,MAAa,wBAAoD;CAC/D,MAAM,MAAM,OAAO;CACnB,QAAQ,SACN,WACG,IAAI,GAAG,CAAC,CACR,SACC,IAGF;AACN"}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { AgUiInterrupt, AgUiInterruptReason, AgUiResumeEntry, AgUiRunFinishedOutcome, UseAgUiRuntimeAdapters, UseAgUiRuntimeOptions, UseAgUiThreadListAdapter } from "./runtime/types.js";
-import { useAgUiInterrupts, useAgUiSteerAway, useAgUiSubmitInterruptResponses } from "./hooks.js";
+import { useAgUiInterrupts, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses } from "./hooks.js";
 import { AgUiAssistantRuntime, useAgUiRuntime } from "./useAgUiRuntime.js";
 import { FromAgUiMessagesOptions, fromAgUiMessages } from "./runtime/adapter/conversions.js";
-export { type AgUiAssistantRuntime, type AgUiInterrupt, type AgUiInterruptReason, type AgUiResumeEntry, type AgUiRunFinishedOutcome, type FromAgUiMessagesOptions, type UseAgUiRuntimeAdapters, type UseAgUiRuntimeOptions, type UseAgUiThreadListAdapter, fromAgUiMessages, useAgUiInterrupts, useAgUiRuntime, useAgUiSteerAway, useAgUiSubmitInterruptResponses };
+export { type AgUiAssistantRuntime, type AgUiInterrupt, type AgUiInterruptReason, type AgUiResumeEntry, type AgUiRunFinishedOutcome, type FromAgUiMessagesOptions, type UseAgUiRuntimeAdapters, type UseAgUiRuntimeOptions, type UseAgUiThreadListAdapter, fromAgUiMessages, useAgUiInterrupts, useAgUiRuntime, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { useAgUiInterrupts, useAgUiSteerAway, useAgUiSubmitInterruptResponses } from "./hooks.js";
+import { useAgUiInterrupts, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses } from "./hooks.js";
 import { fromAgUiMessages } from "./runtime/adapter/conversions.js";
 import { useAgUiRuntime } from "./useAgUiRuntime.js";
-export { fromAgUiMessages, useAgUiInterrupts, useAgUiRuntime, useAgUiSteerAway, useAgUiSubmitInterruptResponses };
+export { fromAgUiMessages, useAgUiInterrupts, useAgUiRuntime, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };

package/dist/runtime/AgUiThreadRuntimeCore.d.ts

@@ -1,9 +1,8 @@
 import { Logger } from "./logger.js";
 import { AgUiInterrupt, AgUiResumeEntry } from "./types.js";
-import { AddToolResultOptions, AppendMessage, AssistantRuntime, ChatModelRunOptions, ChatModelRunResult, CreateAppendMessage, ThreadHistoryAdapter, ThreadMessage } from "@assistant-ui/core";
+import { AddToolResultOptions, AppendMessage, AssistantRuntime, ChatModelRunOptions, ChatModelRunResult, CreateAppendMessage, ExportedMessageRepository, ThreadHistoryAdapter, ThreadMessage } from "@assistant-ui/core";
 import { AbstractAgent } from "@ag-ui/client";
 import { ReadonlyJSONValue } from "assistant-stream/utils";
-
 //#region src/runtime/AgUiThreadRuntimeCore.d.ts
 type RunConfig = NonNullable<AppendMessage["runConfig"]>;
 type ResumeStream = (options: ChatModelRunOptions) => AsyncGenerator<ChatModelRunResult, void, unknown>;
@@ -17,6 +16,7 @@ type CoreOptions = {
   agent: AbstractAgent;
   logger: Logger;
   showThinking: boolean;
+  autoCancelPendingToolCalls?: boolean | undefined;
   onError?: (error: Error) => void;
   onCancel?: () => void;
   history?: ThreadHistoryAdapter;
@@ -26,11 +26,13 @@ declare class AgUiThreadRuntimeCore {
   private agent;
   private logger;
   private showThinking;
+  private autoCancelPendingToolCalls;
   private onError;
   private onCancel;
   private readonly notifyUpdate;
   private runtime;
-  private messages;
+  private readonly repository;
+  private exportedRepository;
   private isRunningFlag;
   private abortController;
   private stateSnapshot;
@@ -47,11 +49,23 @@ declare class AgUiThreadRuntimeCore {
   attachRuntime(runtime: AssistantRuntime): void;
   detachRuntime(): void;
   getMessages(): readonly ThreadMessage[];
+  getMessageRepository(): ExportedMessageRepository;
+  private tryGetMessage;
+  private tryGetMessages;
+  private hasMessage;
+  private addOrUpdateMessage;
+  private deleteMessage;
+  private tryDeleteMessage;
+  private switchToBranch;
+  private resetRepositoryHead;
+  private clearRepository;
+  private updateMessage;
   getState(): ReadonlyJSONValue | undefined;
   isRunning(): boolean;
   get isLoading(): boolean;
   __internal_load(): Promise<void>;
   append(message: AppendMessage): Promise<void>;
+  private maybeAutoCancelPendingToolCalls;
   private appendEntry;
   edit(message: AppendMessage): Promise<void>;
   reload(parentId: string | null, config?: {
@@ -61,22 +75,32 @@ declare class AgUiThreadRuntimeCore {
   resume(config: ResumeRunConfig): Promise<void>;
   resumeInFlightRun(messages: readonly ThreadMessage[]): Promise<void>;
   private assertNoPendingInterrupts;
+  private findRequiresActionAssistant;
   getPendingInterrupts(): {
     messageId: string;
     interrupts: readonly AgUiInterrupt[];
   } | null;
+  getPendingToolCalls(): {
+    messageId: string;
+    toolCallIds: string[];
+  } | null;
   submitInterruptResponses(responses: readonly AgUiResumeEntry[]): Promise<void>;
   steerAway(message: CreateAppendMessage, responses?: readonly AgUiResumeEntry[]): Promise<void>;
   private resolveSteerAwayResume;
+  private collectInterruptResponses;
   private toAppendMessage;
   private clearPendingInterrupts;
   findMessageIdForToolCall(toolCallId: string): string | undefined;
+  private cancelUnresolvedToolCalls;
   addToolResult(options: AddToolResultOptions): void;
   private maybeResumeAfterToolResults;
   private maybeCompleteAfterToolResults;
   private startResumeRun;
   applyExternalMessages(messages: readonly ThreadMessage[]): void;
+  private applyExternalMessageRepository;
   loadExternalState(state: ReadonlyJSONValue): void;
+  setState(next: ReadonlyJSONValue | ((prev: ReadonlyJSONValue | undefined) => ReadonlyJSONValue)): void;
+  resetState(): void;
   private startRun;
   private consumeResumeStream;
   private buildRunInput;
@@ -90,9 +114,9 @@ declare class AgUiThreadRuntimeCore {
   private mergeAssistantMetadata;
   private handleEvent;
   private applyCrossRunToolResult;
+  private applyCrossRunActivitySnapshot;
   private importMessagesSnapshot;
   private toThreadMessage;
-  private resetHead;
   private isTerminalStatus;
   private isPersistableStatus;
   private recordHistoryEntry;

package/dist/runtime/AgUiThreadRuntimeCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AgUiThreadRuntimeCore.d.ts","names":[],"sources":["../../src/runtime/AgUiThreadRuntimeCore.ts"],"mappings":";;;;;;;KAwCK,SAAA,GAAY,WAAW,CAAC,aAAA;AAAA,KACxB,YAAA,IACH,OAAA,EAAS,mBAAA,KACN,cAAA,CAAe,kBAAA;AAAA,KACf,eAAA;EACH,QAAA;EACA,QAAA;EACA,SAAA,EAAW,SAAA;EACX,MAAA,GAAS,YAAY;AAAA;AAAA,KAGlB,WAAA;EACH,KAAA,EAAO,aAAA;EACP,MAAA,EAAQ,MAAA;EACR,YAAA;EACA,OAAA,IAAW,KAAA,EAAO,KAAA;EAClB,QAAA;EACA,OAAA,GAAU,oBAAA;EACV,YAAA;AAAA;AAAA,cAKW,qBAAA;EAAA,QACH,KAAA;EAAA,QACA,MAAA;EAAA,QACA,YAAA;EAAA,QACA,OAAA;EAAA,QACA,QAAA;EAAA,iBACS,YAAA;EAAA,QAET,OAAA;EAAA,QACA,QAAA;EAAA,QACA,aAAA;EAAA,QACA,eAAA;EAAA,QACA,aAAA;EAAA,QACA,YAAA;EAAA,QACA,OAAA;EAAA,QACA,aAAA;EAAA,iBACS,uBAAA;EAAA,iBACA,kBAAA;EAAA,QACT,UAAA;EAAA,QACA,YAAA;EAAA,QACA,sBAAA;cAEI,OAAA,EAAS,WAAA;EAWrB,aAAA,CAAc,OAAA,EAAS,IAAA,CAAK,WAAA;EAU5B,aAAA,CAAc,OAAA,EAAS,gBAAA;EAIvB,aAAA;EAIA,WAAA,aAAwB,aAAA;EAIxB,QAAA,IAAY,iBAAA;EAIZ,SAAA;EAAA,IAII,SAAA;EAIJ,eAAA,IAAmB,OAAA;EA4Cb,MAAA,CAAO,OAAA,EAAS,aAAA,GAAgB,OAAA;EAAA,QAQ9B,WAAA;EAeF,IAAA,CAAK,OAAA,EAAS,aAAA,GAAgB,OAAA;EAI9B,MAAA,CACJ,QAAA,iBACA,MAAA;IAAU,SAAA,GAAY,SAAA;EAAA,IACrB,OAAA;EAOG,MAAA,IAAU,OAAA;EAKV,MAAA,CAAO,MAAA,EAAQ,eAAA,GAAkB,OAAA;EAUjC,iBAAA,CAAkB,QAAA,WAAmB,aAAA,KAAkB,OAAA;EAAA,QAwBrD,yBAAA;EAOR,oBAAA;IACE,SAAA;IACA,UAAA,WAAqB,aAAA;EAAA;EAqBjB,wBAAA,CACJ,SAAA,WAAoB,eAAA,KACnB,OAAA;EAyEG,SAAA,CACJ,OAAA,EAAS,mBAAA,EACT,SAAA,YAAqB,eAAA,KACpB,OAAA;EAAA,QA2BK,sBAAA;EAAA,QAmCA,eAAA;EAAA,QA0BA,sBAAA;EAgCR,wBAAA,CAAyB,UAAA;EAiBzB,aAAA,CAAc,OAAA,EAAS,oBAAA;EAAA,QA+Bf,2BAAA;EAAA,QAYA,6BAAA;EAAA,QA8BA,cAAA;EAMR,qBAAA,CAAsB,QAAA,WAAmB,aAAA;EAUzC,iBAAA,CAAkB,KAAA,EAAO,iBAAA;EAAA,QAKX,QAAA;EAAA,QAqIA,mBAAA;EAAA,QAyDN,aAAA;EAAA,QA2BA,iBAAA;EAAA,QAqBA,UAAA;EAAA,QAKA,SAAA;EAAA,QAOA,0BAAA;EAAA,QAsBA,mBAAA;EAAA,QAmCA,sBAAA;EAAA,QAoDA,mBAAA;EAAA,QAiCA,sBAAA;EAAA,QA6BA,WAAA;EAAA,QA4CA,uBAAA;EAAA,QAmCA,sBAAA;EAAA,QAwBA,eAAA;EAAA,QAQA,SAAA;EAAA,QAYA,gBAAA;EAAA,QAIA,mBAAA;EAAA,QAKA,kBAAA;EAAA,QAIA,2BAAA;EAAA,QAQA,uBAAA;EAAA,QAWA,iBAAA;AAAA"}
+{"version":3,"file":"AgUiThreadRuntimeCore.d.ts","names":[],"sources":["../../src/runtime/AgUiThreadRuntimeCore.ts"],"mappings":";;;;;;KAqDK,YAAY,YAAY;KACxB,gBACH,SAAS,wBACN,eAAe;KACf;EACH;EACA;EACA,WAAW;EACX,SAAS;;KAGN;EACH,OAAO;EACP,QAAQ;EACR;EACA;EACA,WAAW,OAAO;EAClB;EACA,UAAU;EACV;;cAKW;UACH;UACA;UACA;UACA;UACA;UACA;mBACS;UAET;mBACS;UACT;UACA;UACA;UACA;UACA;UACA;UACA;mBACS;mBACA;UACT;UACA;UACA;EAEI,YAAA,SAAS;EAYrB,cAAc,SAAS,KAAK;EAW5B,cAAc,SAAS;EAIvB;EAIA,wBAAwB;EAIxB,wBAAwB;UAmBhB;UAQA;UAUA;UAIA;UAQA;UAQA;UAMA;UAKA;UAKA;UAKA;EAYR,YAAY;EAIZ;MAII;EAIJ,mBAAmB;EA2Cb,OAAO,SAAS,gBAAgB;UAW9B;UAQA;EAiBF,KAAK,SAAS,gBAAgB;EAI9B,OACJ,yBACA;IAAU,YAAY;MACrB;EAMG,UAAU;EAKV,OAAO,QAAQ,kBAAkB;EAUjC,kBAAkB,mBAAmB,kBAAkB;UAwBrD;UAOA;EAgBR;IACE;IACA,qBAAqB;;EAavB;IACE;IACA;;EAcI,yBACJ,oBAAoB,oBACnB;EAoDG,UACJ,SAAS,qBACT,qBAAqB,oBACpB;UAyCK;UAkBA;UAiCA;UA0BA;EA+BR,yBAAyB;UAkBjB;EAiBR,cAAc,SAAS;UA4Bf;UAYA;UA6BA;EAMR,sBAAsB,mBAAmB;UAgDjC;EAgER,kBAAkB,OAAO;EAKzB,SACE,MACI,sBACE,MAAM,kCAAkC;EAOhD;UAKc;UAkJA;UAyDN;UA6BA;UAqBA;UAKA;UAOA;UAuBA;UA2CA;UAiDA;UA4BA;UA6BA;UA4DA;UAuEA;UA8DA;UAwBA;UAQA;UAIA;UAKA;UAIA;UAQA;UAWA"}