@ag-ui/core 0.0.44 → 0.0.45

package/dist/index.js

@@ -1,455 +1,462 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+let zod = require("zod");
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AGUIConnectNotImplementedError: () => AGUIConnectNotImplementedError,
-  AGUIError: () => AGUIError,
-  ActivityDeltaEventSchema: () => ActivityDeltaEventSchema,
-  ActivityMessageSchema: () => ActivityMessageSchema,
-  ActivitySnapshotEventSchema: () => ActivitySnapshotEventSchema,
-  AssistantMessageSchema: () => AssistantMessageSchema,
-  BaseEventSchema: () => BaseEventSchema,
-  BaseMessageSchema: () => BaseMessageSchema,
-  BinaryInputContentSchema: () => BinaryInputContentSchema,
-  ContextSchema: () => ContextSchema,
-  CustomEventSchema: () => CustomEventSchema,
-  DeveloperMessageSchema: () => DeveloperMessageSchema,
-  EventSchemas: () => EventSchemas,
-  EventType: () => EventType,
-  FunctionCallSchema: () => FunctionCallSchema,
-  InputContentSchema: () => InputContentSchema,
-  MessageSchema: () => MessageSchema,
-  MessagesSnapshotEventSchema: () => MessagesSnapshotEventSchema,
-  RawEventSchema: () => RawEventSchema,
-  RoleSchema: () => RoleSchema,
-  RunAgentInputSchema: () => RunAgentInputSchema,
-  RunErrorEventSchema: () => RunErrorEventSchema,
-  RunFinishedEventSchema: () => RunFinishedEventSchema,
-  RunStartedEventSchema: () => RunStartedEventSchema,
-  StateDeltaEventSchema: () => StateDeltaEventSchema,
-  StateSchema: () => StateSchema,
-  StateSnapshotEventSchema: () => StateSnapshotEventSchema,
-  StepFinishedEventSchema: () => StepFinishedEventSchema,
-  StepStartedEventSchema: () => StepStartedEventSchema,
-  SystemMessageSchema: () => SystemMessageSchema,
-  TextInputContentSchema: () => TextInputContentSchema,
-  TextMessageChunkEventSchema: () => TextMessageChunkEventSchema,
-  TextMessageContentEventSchema: () => TextMessageContentEventSchema,
-  TextMessageEndEventSchema: () => TextMessageEndEventSchema,
-  TextMessageStartEventSchema: () => TextMessageStartEventSchema,
-  ThinkingEndEventSchema: () => ThinkingEndEventSchema,
-  ThinkingStartEventSchema: () => ThinkingStartEventSchema,
-  ThinkingTextMessageContentEventSchema: () => ThinkingTextMessageContentEventSchema,
-  ThinkingTextMessageEndEventSchema: () => ThinkingTextMessageEndEventSchema,
-  ThinkingTextMessageStartEventSchema: () => ThinkingTextMessageStartEventSchema,
-  ToolCallArgsEventSchema: () => ToolCallArgsEventSchema,
-  ToolCallChunkEventSchema: () => ToolCallChunkEventSchema,
-  ToolCallEndEventSchema: () => ToolCallEndEventSchema,
-  ToolCallResultEventSchema: () => ToolCallResultEventSchema,
-  ToolCallSchema: () => ToolCallSchema,
-  ToolCallStartEventSchema: () => ToolCallStartEventSchema,
-  ToolMessageSchema: () => ToolMessageSchema,
-  ToolSchema: () => ToolSchema,
-  UserMessageSchema: () => UserMessageSchema
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/types.ts
-var import_zod = require("zod");
-var FunctionCallSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  arguments: import_zod.z.string()
-});
-var ToolCallSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  type: import_zod.z.literal("function"),
-  function: FunctionCallSchema
-});
-var BaseMessageSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  role: import_zod.z.string(),
-  content: import_zod.z.string().optional(),
-  name: import_zod.z.string().optional()
-});
-var TextInputContentSchema = import_zod.z.object({
-  type: import_zod.z.literal("text"),
-  text: import_zod.z.string()
-});
-var BinaryInputContentObjectSchema = import_zod.z.object({
-  type: import_zod.z.literal("binary"),
-  mimeType: import_zod.z.string(),
-  id: import_zod.z.string().optional(),
-  url: import_zod.z.string().optional(),
-  data: import_zod.z.string().optional(),
-  filename: import_zod.z.string().optional()
-});
-var ensureBinaryPayload = (value, ctx) => {
-  if (!value.id && !value.url && !value.data) {
-    ctx.addIssue({
-      code: import_zod.z.ZodIssueCode.custom,
-      message: "BinaryInputContent requires at least one of id, url, or data.",
-      path: ["id"]
-    });
-  }
+//#region src/types.ts
+const FunctionCallSchema = zod.z.object({
+	name: zod.z.string(),
+	arguments: zod.z.string()
+});
+const ToolCallSchema = zod.z.object({
+	id: zod.z.string(),
+	type: zod.z.literal("function"),
+	function: FunctionCallSchema,
+	encryptedValue: zod.z.string().optional()
+});
+const BaseMessageSchema = zod.z.object({
+	id: zod.z.string(),
+	role: zod.z.string(),
+	content: zod.z.string().optional(),
+	name: zod.z.string().optional(),
+	encryptedValue: zod.z.string().optional()
+});
+const TextInputContentSchema = zod.z.object({
+	type: zod.z.literal("text"),
+	text: zod.z.string()
+});
+const BinaryInputContentObjectSchema = zod.z.object({
+	type: zod.z.literal("binary"),
+	mimeType: zod.z.string(),
+	id: zod.z.string().optional(),
+	url: zod.z.string().optional(),
+	data: zod.z.string().optional(),
+	filename: zod.z.string().optional()
+});
+const ensureBinaryPayload = (value, ctx) => {
+	if (!value.id && !value.url && !value.data) ctx.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		message: "BinaryInputContent requires at least one of id, url, or data.",
+		path: ["id"]
+	});
 };
-var BinaryInputContentSchema = BinaryInputContentObjectSchema.superRefine((value, ctx) => {
-  ensureBinaryPayload(value, ctx);
-});
-var InputContentBaseSchema = import_zod.z.discriminatedUnion("type", [
-  TextInputContentSchema,
-  BinaryInputContentObjectSchema
+const BinaryInputContentSchema = BinaryInputContentObjectSchema.superRefine((value, ctx) => {
+	ensureBinaryPayload(value, ctx);
+});
+const InputContentBaseSchema = zod.z.discriminatedUnion("type", [TextInputContentSchema, BinaryInputContentObjectSchema]);
+const InputContentSchema = InputContentBaseSchema.superRefine((value, ctx) => {
+	if (value.type === "binary") ensureBinaryPayload(value, ctx);
+});
+const DeveloperMessageSchema = BaseMessageSchema.extend({
+	role: zod.z.literal("developer"),
+	content: zod.z.string()
+});
+const SystemMessageSchema = BaseMessageSchema.extend({
+	role: zod.z.literal("system"),
+	content: zod.z.string()
+});
+const AssistantMessageSchema = BaseMessageSchema.extend({
+	role: zod.z.literal("assistant"),
+	content: zod.z.string().optional(),
+	toolCalls: zod.z.array(ToolCallSchema).optional()
+});
+const UserMessageSchema = BaseMessageSchema.extend({
+	role: zod.z.literal("user"),
+	content: zod.z.union([zod.z.string(), zod.z.array(InputContentSchema)])
+});
+const ToolMessageSchema = zod.z.object({
+	id: zod.z.string(),
+	content: zod.z.string(),
+	role: zod.z.literal("tool"),
+	toolCallId: zod.z.string(),
+	error: zod.z.string().optional(),
+	encryptedValue: zod.z.string().optional()
+});
+const ActivityMessageSchema = zod.z.object({
+	id: zod.z.string(),
+	role: zod.z.literal("activity"),
+	activityType: zod.z.string(),
+	content: zod.z.record(zod.z.any())
+});
+const ReasoningMessageSchema = zod.z.object({
+	id: zod.z.string(),
+	role: zod.z.literal("reasoning"),
+	content: zod.z.string(),
+	encryptedValue: zod.z.string().optional()
+});
+const MessageSchema = zod.z.discriminatedUnion("role", [
+	DeveloperMessageSchema,
+	SystemMessageSchema,
+	AssistantMessageSchema,
+	UserMessageSchema,
+	ToolMessageSchema,
+	ActivityMessageSchema,
+	ReasoningMessageSchema
 ]);
-var InputContentSchema = InputContentBaseSchema.superRefine((value, ctx) => {
-  if (value.type === "binary") {
-    ensureBinaryPayload(value, ctx);
-  }
-});
-var DeveloperMessageSchema = BaseMessageSchema.extend({
-  role: import_zod.z.literal("developer"),
-  content: import_zod.z.string()
-});
-var SystemMessageSchema = BaseMessageSchema.extend({
-  role: import_zod.z.literal("system"),
-  content: import_zod.z.string()
-});
-var AssistantMessageSchema = BaseMessageSchema.extend({
-  role: import_zod.z.literal("assistant"),
-  content: import_zod.z.string().optional(),
-  toolCalls: import_zod.z.array(ToolCallSchema).optional()
-});
-var UserMessageSchema = BaseMessageSchema.extend({
-  role: import_zod.z.literal("user"),
-  content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(InputContentSchema)])
-});
-var ToolMessageSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  content: import_zod.z.string(),
-  role: import_zod.z.literal("tool"),
-  toolCallId: import_zod.z.string(),
-  error: import_zod.z.string().optional()
-});
-var ActivityMessageSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  role: import_zod.z.literal("activity"),
-  activityType: import_zod.z.string(),
-  content: import_zod.z.record(import_zod.z.any())
-});
-var MessageSchema = import_zod.z.discriminatedUnion("role", [
-  DeveloperMessageSchema,
-  SystemMessageSchema,
-  AssistantMessageSchema,
-  UserMessageSchema,
-  ToolMessageSchema,
-  ActivityMessageSchema
+const RoleSchema = zod.z.union([
+	zod.z.literal("developer"),
+	zod.z.literal("system"),
+	zod.z.literal("assistant"),
+	zod.z.literal("user"),
+	zod.z.literal("tool"),
+	zod.z.literal("activity"),
+	zod.z.literal("reasoning")
 ]);
-var RoleSchema = import_zod.z.union([
-  import_zod.z.literal("developer"),
-  import_zod.z.literal("system"),
-  import_zod.z.literal("assistant"),
-  import_zod.z.literal("user"),
-  import_zod.z.literal("tool"),
-  import_zod.z.literal("activity")
-]);
-var ContextSchema = import_zod.z.object({
-  description: import_zod.z.string(),
-  value: import_zod.z.string()
-});
-var ToolSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  description: import_zod.z.string(),
-  parameters: import_zod.z.any()
-  // JSON Schema for the tool parameters
-});
-var RunAgentInputSchema = import_zod.z.object({
-  threadId: import_zod.z.string(),
-  runId: import_zod.z.string(),
-  parentRunId: import_zod.z.string().optional(),
-  state: import_zod.z.any(),
-  messages: import_zod.z.array(MessageSchema),
-  tools: import_zod.z.array(ToolSchema),
-  context: import_zod.z.array(ContextSchema),
-  forwardedProps: import_zod.z.any()
-});
-var StateSchema = import_zod.z.any();
+const ContextSchema = zod.z.object({
+	description: zod.z.string(),
+	value: zod.z.string()
+});
+const ToolSchema = zod.z.object({
+	name: zod.z.string(),
+	description: zod.z.string(),
+	parameters: zod.z.any()
+});
+const RunAgentInputSchema = zod.z.object({
+	threadId: zod.z.string(),
+	runId: zod.z.string(),
+	parentRunId: zod.z.string().optional(),
+	state: zod.z.any(),
+	messages: zod.z.array(MessageSchema),
+	tools: zod.z.array(ToolSchema),
+	context: zod.z.array(ContextSchema),
+	forwardedProps: zod.z.any()
+});
+const StateSchema = zod.z.any();
 var AGUIError = class extends Error {
-  constructor(message) {
-    super(message);
-  }
+	constructor(message) {
+		super(message);
+	}
 };
 var AGUIConnectNotImplementedError = class extends AGUIError {
-  constructor() {
-    super("Connect not implemented. This method is not supported by the current agent.");
-  }
+	constructor() {
+		super("Connect not implemented. This method is not supported by the current agent.");
+	}
 };
 
-// src/events.ts
-var import_zod2 = require("zod");
-var TextMessageRoleSchema = import_zod2.z.union([
-  import_zod2.z.literal("developer"),
-  import_zod2.z.literal("system"),
-  import_zod2.z.literal("assistant"),
-  import_zod2.z.literal("user")
+//#endregion
+//#region src/events.ts
+const TextMessageRoleSchema = zod.z.union([
+	zod.z.literal("developer"),
+	zod.z.literal("system"),
+	zod.z.literal("assistant"),
+	zod.z.literal("user")
 ]);
-var EventType = /* @__PURE__ */ ((EventType2) => {
-  EventType2["TEXT_MESSAGE_START"] = "TEXT_MESSAGE_START";
-  EventType2["TEXT_MESSAGE_CONTENT"] = "TEXT_MESSAGE_CONTENT";
-  EventType2["TEXT_MESSAGE_END"] = "TEXT_MESSAGE_END";
-  EventType2["TEXT_MESSAGE_CHUNK"] = "TEXT_MESSAGE_CHUNK";
-  EventType2["THINKING_TEXT_MESSAGE_START"] = "THINKING_TEXT_MESSAGE_START";
-  EventType2["THINKING_TEXT_MESSAGE_CONTENT"] = "THINKING_TEXT_MESSAGE_CONTENT";
-  EventType2["THINKING_TEXT_MESSAGE_END"] = "THINKING_TEXT_MESSAGE_END";
-  EventType2["TOOL_CALL_START"] = "TOOL_CALL_START";
-  EventType2["TOOL_CALL_ARGS"] = "TOOL_CALL_ARGS";
-  EventType2["TOOL_CALL_END"] = "TOOL_CALL_END";
-  EventType2["TOOL_CALL_CHUNK"] = "TOOL_CALL_CHUNK";
-  EventType2["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
-  EventType2["THINKING_START"] = "THINKING_START";
-  EventType2["THINKING_END"] = "THINKING_END";
-  EventType2["STATE_SNAPSHOT"] = "STATE_SNAPSHOT";
-  EventType2["STATE_DELTA"] = "STATE_DELTA";
-  EventType2["MESSAGES_SNAPSHOT"] = "MESSAGES_SNAPSHOT";
-  EventType2["ACTIVITY_SNAPSHOT"] = "ACTIVITY_SNAPSHOT";
-  EventType2["ACTIVITY_DELTA"] = "ACTIVITY_DELTA";
-  EventType2["RAW"] = "RAW";
-  EventType2["CUSTOM"] = "CUSTOM";
-  EventType2["RUN_STARTED"] = "RUN_STARTED";
-  EventType2["RUN_FINISHED"] = "RUN_FINISHED";
-  EventType2["RUN_ERROR"] = "RUN_ERROR";
-  EventType2["STEP_STARTED"] = "STEP_STARTED";
-  EventType2["STEP_FINISHED"] = "STEP_FINISHED";
-  return EventType2;
-})(EventType || {});
-var BaseEventSchema = import_zod2.z.object({
-  type: import_zod2.z.nativeEnum(EventType),
-  timestamp: import_zod2.z.number().optional(),
-  rawEvent: import_zod2.z.any().optional()
+let EventType = /* @__PURE__ */ function(EventType) {
+	EventType["TEXT_MESSAGE_START"] = "TEXT_MESSAGE_START";
+	EventType["TEXT_MESSAGE_CONTENT"] = "TEXT_MESSAGE_CONTENT";
+	EventType["TEXT_MESSAGE_END"] = "TEXT_MESSAGE_END";
+	EventType["TEXT_MESSAGE_CHUNK"] = "TEXT_MESSAGE_CHUNK";
+	EventType["TOOL_CALL_START"] = "TOOL_CALL_START";
+	EventType["TOOL_CALL_ARGS"] = "TOOL_CALL_ARGS";
+	EventType["TOOL_CALL_END"] = "TOOL_CALL_END";
+	EventType["TOOL_CALL_CHUNK"] = "TOOL_CALL_CHUNK";
+	EventType["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
+	/**
+	* @deprecated Use REASONING_START instead. Will be removed in 1.0.0.
+	*/
+	EventType["THINKING_START"] = "THINKING_START";
+	/**
+	* @deprecated Use REASONING_END instead. Will be removed in 1.0.0.
+	*/
+	EventType["THINKING_END"] = "THINKING_END";
+	/**
+	* @deprecated Use REASONING_MESSAGE_START instead. Will be removed in 1.0.0.
+	*/
+	EventType["THINKING_TEXT_MESSAGE_START"] = "THINKING_TEXT_MESSAGE_START";
+	/**
+	* @deprecated Use REASONING_MESSAGE_CONTENT instead. Will be removed in 1.0.0.
+	*/
+	EventType["THINKING_TEXT_MESSAGE_CONTENT"] = "THINKING_TEXT_MESSAGE_CONTENT";
+	/**
+	* @deprecated Use REASONING_MESSAGE_END instead. Will be removed in 1.0.0.
+	*/
+	EventType["THINKING_TEXT_MESSAGE_END"] = "THINKING_TEXT_MESSAGE_END";
+	EventType["STATE_SNAPSHOT"] = "STATE_SNAPSHOT";
+	EventType["STATE_DELTA"] = "STATE_DELTA";
+	EventType["MESSAGES_SNAPSHOT"] = "MESSAGES_SNAPSHOT";
+	EventType["ACTIVITY_SNAPSHOT"] = "ACTIVITY_SNAPSHOT";
+	EventType["ACTIVITY_DELTA"] = "ACTIVITY_DELTA";
+	EventType["RAW"] = "RAW";
+	EventType["CUSTOM"] = "CUSTOM";
+	EventType["RUN_STARTED"] = "RUN_STARTED";
+	EventType["RUN_FINISHED"] = "RUN_FINISHED";
+	EventType["RUN_ERROR"] = "RUN_ERROR";
+	EventType["STEP_STARTED"] = "STEP_STARTED";
+	EventType["STEP_FINISHED"] = "STEP_FINISHED";
+	EventType["REASONING_START"] = "REASONING_START";
+	EventType["REASONING_MESSAGE_START"] = "REASONING_MESSAGE_START";
+	EventType["REASONING_MESSAGE_CONTENT"] = "REASONING_MESSAGE_CONTENT";
+	EventType["REASONING_MESSAGE_END"] = "REASONING_MESSAGE_END";
+	EventType["REASONING_MESSAGE_CHUNK"] = "REASONING_MESSAGE_CHUNK";
+	EventType["REASONING_END"] = "REASONING_END";
+	EventType["REASONING_ENCRYPTED_VALUE"] = "REASONING_ENCRYPTED_VALUE";
+	return EventType;
+}({});
+const BaseEventSchema = zod.z.object({
+	type: zod.z.nativeEnum(EventType),
+	timestamp: zod.z.number().optional(),
+	rawEvent: zod.z.any().optional()
 }).passthrough();
-var TextMessageStartEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("TEXT_MESSAGE_START" /* TEXT_MESSAGE_START */),
-  messageId: import_zod2.z.string(),
-  role: TextMessageRoleSchema.default("assistant")
-});
-var TextMessageContentEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("TEXT_MESSAGE_CONTENT" /* TEXT_MESSAGE_CONTENT */),
-  messageId: import_zod2.z.string(),
-  delta: import_zod2.z.string().refine((s) => s.length > 0, "Delta must not be an empty string")
-});
-var TextMessageEndEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("TEXT_MESSAGE_END" /* TEXT_MESSAGE_END */),
-  messageId: import_zod2.z.string()
-});
-var TextMessageChunkEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("TEXT_MESSAGE_CHUNK" /* TEXT_MESSAGE_CHUNK */),
-  messageId: import_zod2.z.string().optional(),
-  role: TextMessageRoleSchema.optional(),
-  delta: import_zod2.z.string().optional()
-});
-var ThinkingTextMessageStartEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("THINKING_TEXT_MESSAGE_START" /* THINKING_TEXT_MESSAGE_START */)
-});
-var ThinkingTextMessageContentEventSchema = TextMessageContentEventSchema.omit({
-  messageId: true,
-  type: true
-}).extend({
-  type: import_zod2.z.literal("THINKING_TEXT_MESSAGE_CONTENT" /* THINKING_TEXT_MESSAGE_CONTENT */)
-});
-var ThinkingTextMessageEndEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("THINKING_TEXT_MESSAGE_END" /* THINKING_TEXT_MESSAGE_END */)
-});
-var ToolCallStartEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("TOOL_CALL_START" /* TOOL_CALL_START */),
-  toolCallId: import_zod2.z.string(),
-  toolCallName: import_zod2.z.string(),
-  parentMessageId: import_zod2.z.string().optional()
-});
-var ToolCallArgsEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("TOOL_CALL_ARGS" /* TOOL_CALL_ARGS */),
-  toolCallId: import_zod2.z.string(),
-  delta: import_zod2.z.string()
-});
-var ToolCallEndEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("TOOL_CALL_END" /* TOOL_CALL_END */),
-  toolCallId: import_zod2.z.string()
-});
-var ToolCallResultEventSchema = BaseEventSchema.extend({
-  messageId: import_zod2.z.string(),
-  type: import_zod2.z.literal("TOOL_CALL_RESULT" /* TOOL_CALL_RESULT */),
-  toolCallId: import_zod2.z.string(),
-  content: import_zod2.z.string(),
-  role: import_zod2.z.literal("tool").optional()
-});
-var ToolCallChunkEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("TOOL_CALL_CHUNK" /* TOOL_CALL_CHUNK */),
-  toolCallId: import_zod2.z.string().optional(),
-  toolCallName: import_zod2.z.string().optional(),
-  parentMessageId: import_zod2.z.string().optional(),
-  delta: import_zod2.z.string().optional()
-});
-var ThinkingStartEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("THINKING_START" /* THINKING_START */),
-  title: import_zod2.z.string().optional()
-});
-var ThinkingEndEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("THINKING_END" /* THINKING_END */)
-});
-var StateSnapshotEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("STATE_SNAPSHOT" /* STATE_SNAPSHOT */),
-  snapshot: StateSchema
-});
-var StateDeltaEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("STATE_DELTA" /* STATE_DELTA */),
-  delta: import_zod2.z.array(import_zod2.z.any())
-  // JSON Patch (RFC 6902)
-});
-var MessagesSnapshotEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("MESSAGES_SNAPSHOT" /* MESSAGES_SNAPSHOT */),
-  messages: import_zod2.z.array(MessageSchema)
-});
-var ActivitySnapshotEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("ACTIVITY_SNAPSHOT" /* ACTIVITY_SNAPSHOT */),
-  messageId: import_zod2.z.string(),
-  activityType: import_zod2.z.string(),
-  content: import_zod2.z.record(import_zod2.z.any()),
-  replace: import_zod2.z.boolean().optional().default(true)
-});
-var ActivityDeltaEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("ACTIVITY_DELTA" /* ACTIVITY_DELTA */),
-  messageId: import_zod2.z.string(),
-  activityType: import_zod2.z.string(),
-  patch: import_zod2.z.array(import_zod2.z.any())
-});
-var RawEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("RAW" /* RAW */),
-  event: import_zod2.z.any(),
-  source: import_zod2.z.string().optional()
-});
-var CustomEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("CUSTOM" /* CUSTOM */),
-  name: import_zod2.z.string(),
-  value: import_zod2.z.any()
-});
-var RunStartedEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("RUN_STARTED" /* RUN_STARTED */),
-  threadId: import_zod2.z.string(),
-  runId: import_zod2.z.string(),
-  parentRunId: import_zod2.z.string().optional(),
-  input: RunAgentInputSchema.optional()
-});
-var RunFinishedEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("RUN_FINISHED" /* RUN_FINISHED */),
-  threadId: import_zod2.z.string(),
-  runId: import_zod2.z.string(),
-  result: import_zod2.z.any().optional()
-});
-var RunErrorEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("RUN_ERROR" /* RUN_ERROR */),
-  message: import_zod2.z.string(),
-  code: import_zod2.z.string().optional()
-});
-var StepStartedEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("STEP_STARTED" /* STEP_STARTED */),
-  stepName: import_zod2.z.string()
-});
-var StepFinishedEventSchema = BaseEventSchema.extend({
-  type: import_zod2.z.literal("STEP_FINISHED" /* STEP_FINISHED */),
-  stepName: import_zod2.z.string()
-});
-var EventSchemas = import_zod2.z.discriminatedUnion("type", [
-  TextMessageStartEventSchema,
-  TextMessageContentEventSchema,
-  TextMessageEndEventSchema,
-  TextMessageChunkEventSchema,
-  ThinkingStartEventSchema,
-  ThinkingEndEventSchema,
-  ThinkingTextMessageStartEventSchema,
-  ThinkingTextMessageContentEventSchema,
-  ThinkingTextMessageEndEventSchema,
-  ToolCallStartEventSchema,
-  ToolCallArgsEventSchema,
-  ToolCallEndEventSchema,
-  ToolCallChunkEventSchema,
-  ToolCallResultEventSchema,
-  StateSnapshotEventSchema,
-  StateDeltaEventSchema,
-  MessagesSnapshotEventSchema,
-  ActivitySnapshotEventSchema,
-  ActivityDeltaEventSchema,
-  RawEventSchema,
-  CustomEventSchema,
-  RunStartedEventSchema,
-  RunFinishedEventSchema,
-  RunErrorEventSchema,
-  StepStartedEventSchema,
-  StepFinishedEventSchema
+const TextMessageStartEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.TEXT_MESSAGE_START),
+	messageId: zod.z.string(),
+	role: TextMessageRoleSchema.default("assistant")
+});
+const TextMessageContentEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.TEXT_MESSAGE_CONTENT),
+	messageId: zod.z.string(),
+	delta: zod.z.string().refine((s) => s.length > 0, "Delta must not be an empty string")
+});
+const TextMessageEndEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.TEXT_MESSAGE_END),
+	messageId: zod.z.string()
+});
+const TextMessageChunkEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.TEXT_MESSAGE_CHUNK),
+	messageId: zod.z.string().optional(),
+	role: TextMessageRoleSchema.optional(),
+	delta: zod.z.string().optional()
+});
+/**
+* @deprecated Use ReasoningMessageStartEventSchema instead. Will be removed in 1.0.0.
+*/
+const ThinkingTextMessageStartEventSchema = BaseEventSchema.extend({ type: zod.z.literal(EventType.THINKING_TEXT_MESSAGE_START) });
+/**
+* @deprecated Use ReasoningMessageContentEventSchema instead. Will be removed in 1.0.0.
+*/
+const ThinkingTextMessageContentEventSchema = TextMessageContentEventSchema.omit({
+	messageId: true,
+	type: true
+}).extend({ type: zod.z.literal(EventType.THINKING_TEXT_MESSAGE_CONTENT) });
+/**
+* @deprecated Use ReasoningMessageEndEventSchema instead. Will be removed in 1.0.0.
+*/
+const ThinkingTextMessageEndEventSchema = BaseEventSchema.extend({ type: zod.z.literal(EventType.THINKING_TEXT_MESSAGE_END) });
+const ToolCallStartEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.TOOL_CALL_START),
+	toolCallId: zod.z.string(),
+	toolCallName: zod.z.string(),
+	parentMessageId: zod.z.string().optional()
+});
+const ToolCallArgsEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.TOOL_CALL_ARGS),
+	toolCallId: zod.z.string(),
+	delta: zod.z.string()
+});
+const ToolCallEndEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.TOOL_CALL_END),
+	toolCallId: zod.z.string()
+});
+const ToolCallResultEventSchema = BaseEventSchema.extend({
+	messageId: zod.z.string(),
+	type: zod.z.literal(EventType.TOOL_CALL_RESULT),
+	toolCallId: zod.z.string(),
+	content: zod.z.string(),
+	role: zod.z.literal("tool").optional()
+});
+const ToolCallChunkEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.TOOL_CALL_CHUNK),
+	toolCallId: zod.z.string().optional(),
+	toolCallName: zod.z.string().optional(),
+	parentMessageId: zod.z.string().optional(),
+	delta: zod.z.string().optional()
+});
+/**
+* @deprecated Use ReasoningStartEventSchema instead. Will be removed in 1.0.0.
+*/
+const ThinkingStartEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.THINKING_START),
+	title: zod.z.string().optional()
+});
+/**
+* @deprecated Use ReasoningEndEventSchema instead. Will be removed in 1.0.0.
+*/
+const ThinkingEndEventSchema = BaseEventSchema.extend({ type: zod.z.literal(EventType.THINKING_END) });
+const StateSnapshotEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.STATE_SNAPSHOT),
+	snapshot: StateSchema
+});
+const StateDeltaEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.STATE_DELTA),
+	delta: zod.z.array(zod.z.any())
+});
+const MessagesSnapshotEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.MESSAGES_SNAPSHOT),
+	messages: zod.z.array(MessageSchema)
+});
+const ActivitySnapshotEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.ACTIVITY_SNAPSHOT),
+	messageId: zod.z.string(),
+	activityType: zod.z.string(),
+	content: zod.z.record(zod.z.any()),
+	replace: zod.z.boolean().optional().default(true)
+});
+const ActivityDeltaEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.ACTIVITY_DELTA),
+	messageId: zod.z.string(),
+	activityType: zod.z.string(),
+	patch: zod.z.array(zod.z.any())
+});
+const RawEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.RAW),
+	event: zod.z.any(),
+	source: zod.z.string().optional()
+});
+const CustomEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.CUSTOM),
+	name: zod.z.string(),
+	value: zod.z.any()
+});
+const RunStartedEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.RUN_STARTED),
+	threadId: zod.z.string(),
+	runId: zod.z.string(),
+	parentRunId: zod.z.string().optional(),
+	input: RunAgentInputSchema.optional()
+});
+const RunFinishedEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.RUN_FINISHED),
+	threadId: zod.z.string(),
+	runId: zod.z.string(),
+	result: zod.z.any().optional()
+});
+const RunErrorEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.RUN_ERROR),
+	message: zod.z.string(),
+	code: zod.z.string().optional()
+});
+const StepStartedEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.STEP_STARTED),
+	stepName: zod.z.string()
+});
+const StepFinishedEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.STEP_FINISHED),
+	stepName: zod.z.string()
+});
+const ReasoningEncryptedValueSubtypeSchema = zod.z.union([zod.z.literal("tool-call"), zod.z.literal("message")]);
+const ReasoningStartEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.REASONING_START),
+	messageId: zod.z.string()
+});
+const ReasoningMessageStartEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.REASONING_MESSAGE_START),
+	messageId: zod.z.string(),
+	role: zod.z.literal("reasoning")
+});
+const ReasoningMessageContentEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.REASONING_MESSAGE_CONTENT),
+	messageId: zod.z.string(),
+	delta: zod.z.string().refine((s) => s.length > 0, "Delta must not be an empty string")
+});
+const ReasoningMessageEndEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.REASONING_MESSAGE_END),
+	messageId: zod.z.string()
+});
+const ReasoningMessageChunkEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.REASONING_MESSAGE_CHUNK),
+	messageId: zod.z.string().optional(),
+	delta: zod.z.string().optional()
+});
+const ReasoningEndEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.REASONING_END),
+	messageId: zod.z.string()
+});
+const ReasoningEncryptedValueEventSchema = BaseEventSchema.extend({
+	type: zod.z.literal(EventType.REASONING_ENCRYPTED_VALUE),
+	subtype: ReasoningEncryptedValueSubtypeSchema,
+	entityId: zod.z.string(),
+	encryptedValue: zod.z.string()
+});
+const EventSchemas = zod.z.discriminatedUnion("type", [
+	TextMessageStartEventSchema,
+	TextMessageContentEventSchema,
+	TextMessageEndEventSchema,
+	TextMessageChunkEventSchema,
+	ThinkingStartEventSchema,
+	ThinkingEndEventSchema,
+	ThinkingTextMessageStartEventSchema,
+	ThinkingTextMessageContentEventSchema,
+	ThinkingTextMessageEndEventSchema,
+	ToolCallStartEventSchema,
+	ToolCallArgsEventSchema,
+	ToolCallEndEventSchema,
+	ToolCallChunkEventSchema,
+	ToolCallResultEventSchema,
+	StateSnapshotEventSchema,
+	StateDeltaEventSchema,
+	MessagesSnapshotEventSchema,
+	ActivitySnapshotEventSchema,
+	ActivityDeltaEventSchema,
+	RawEventSchema,
+	CustomEventSchema,
+	RunStartedEventSchema,
+	RunFinishedEventSchema,
+	RunErrorEventSchema,
+	StepStartedEventSchema,
+	StepFinishedEventSchema,
+	ReasoningStartEventSchema,
+	ReasoningMessageStartEventSchema,
+	ReasoningMessageContentEventSchema,
+	ReasoningMessageEndEventSchema,
+	ReasoningMessageChunkEventSchema,
+	ReasoningEndEventSchema,
+	ReasoningEncryptedValueEventSchema
 ]);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AGUIConnectNotImplementedError,
-  AGUIError,
-  ActivityDeltaEventSchema,
-  ActivityMessageSchema,
-  ActivitySnapshotEventSchema,
-  AssistantMessageSchema,
-  BaseEventSchema,
-  BaseMessageSchema,
-  BinaryInputContentSchema,
-  ContextSchema,
-  CustomEventSchema,
-  DeveloperMessageSchema,
-  EventSchemas,
-  EventType,
-  FunctionCallSchema,
-  InputContentSchema,
-  MessageSchema,
-  MessagesSnapshotEventSchema,
-  RawEventSchema,
-  RoleSchema,
-  RunAgentInputSchema,
-  RunErrorEventSchema,
-  RunFinishedEventSchema,
-  RunStartedEventSchema,
-  StateDeltaEventSchema,
-  StateSchema,
-  StateSnapshotEventSchema,
-  StepFinishedEventSchema,
-  StepStartedEventSchema,
-  SystemMessageSchema,
-  TextInputContentSchema,
-  TextMessageChunkEventSchema,
-  TextMessageContentEventSchema,
-  TextMessageEndEventSchema,
-  TextMessageStartEventSchema,
-  ThinkingEndEventSchema,
-  ThinkingStartEventSchema,
-  ThinkingTextMessageContentEventSchema,
-  ThinkingTextMessageEndEventSchema,
-  ThinkingTextMessageStartEventSchema,
-  ToolCallArgsEventSchema,
-  ToolCallChunkEventSchema,
-  ToolCallEndEventSchema,
-  ToolCallResultEventSchema,
-  ToolCallSchema,
-  ToolCallStartEventSchema,
-  ToolMessageSchema,
-  ToolSchema,
-  UserMessageSchema
-});
+
+//#endregion
+exports.AGUIConnectNotImplementedError = AGUIConnectNotImplementedError;
+exports.AGUIError = AGUIError;
+exports.ActivityDeltaEventSchema = ActivityDeltaEventSchema;
+exports.ActivityMessageSchema = ActivityMessageSchema;
+exports.ActivitySnapshotEventSchema = ActivitySnapshotEventSchema;
+exports.AssistantMessageSchema = AssistantMessageSchema;
+exports.BaseEventSchema = BaseEventSchema;
+exports.BaseMessageSchema = BaseMessageSchema;
+exports.BinaryInputContentSchema = BinaryInputContentSchema;
+exports.ContextSchema = ContextSchema;
+exports.CustomEventSchema = CustomEventSchema;
+exports.DeveloperMessageSchema = DeveloperMessageSchema;
+exports.EventSchemas = EventSchemas;
+exports.EventType = EventType;
+exports.FunctionCallSchema = FunctionCallSchema;
+exports.InputContentSchema = InputContentSchema;
+exports.MessageSchema = MessageSchema;
+exports.MessagesSnapshotEventSchema = MessagesSnapshotEventSchema;
+exports.RawEventSchema = RawEventSchema;
+exports.ReasoningEncryptedValueEventSchema = ReasoningEncryptedValueEventSchema;
+exports.ReasoningEncryptedValueSubtypeSchema = ReasoningEncryptedValueSubtypeSchema;
+exports.ReasoningEndEventSchema = ReasoningEndEventSchema;
+exports.ReasoningMessageChunkEventSchema = ReasoningMessageChunkEventSchema;
+exports.ReasoningMessageContentEventSchema = ReasoningMessageContentEventSchema;
+exports.ReasoningMessageEndEventSchema = ReasoningMessageEndEventSchema;
+exports.ReasoningMessageSchema = ReasoningMessageSchema;
+exports.ReasoningMessageStartEventSchema = ReasoningMessageStartEventSchema;
+exports.ReasoningStartEventSchema = ReasoningStartEventSchema;
+exports.RoleSchema = RoleSchema;
+exports.RunAgentInputSchema = RunAgentInputSchema;
+exports.RunErrorEventSchema = RunErrorEventSchema;
+exports.RunFinishedEventSchema = RunFinishedEventSchema;
+exports.RunStartedEventSchema = RunStartedEventSchema;
+exports.StateDeltaEventSchema = StateDeltaEventSchema;
+exports.StateSchema = StateSchema;
+exports.StateSnapshotEventSchema = StateSnapshotEventSchema;
+exports.StepFinishedEventSchema = StepFinishedEventSchema;
+exports.StepStartedEventSchema = StepStartedEventSchema;
+exports.SystemMessageSchema = SystemMessageSchema;
+exports.TextInputContentSchema = TextInputContentSchema;
+exports.TextMessageChunkEventSchema = TextMessageChunkEventSchema;
+exports.TextMessageContentEventSchema = TextMessageContentEventSchema;
+exports.TextMessageEndEventSchema = TextMessageEndEventSchema;
+exports.TextMessageStartEventSchema = TextMessageStartEventSchema;
+exports.ThinkingEndEventSchema = ThinkingEndEventSchema;
+exports.ThinkingStartEventSchema = ThinkingStartEventSchema;
+exports.ThinkingTextMessageContentEventSchema = ThinkingTextMessageContentEventSchema;
+exports.ThinkingTextMessageEndEventSchema = ThinkingTextMessageEndEventSchema;
+exports.ThinkingTextMessageStartEventSchema = ThinkingTextMessageStartEventSchema;
+exports.ToolCallArgsEventSchema = ToolCallArgsEventSchema;
+exports.ToolCallChunkEventSchema = ToolCallChunkEventSchema;
+exports.ToolCallEndEventSchema = ToolCallEndEventSchema;
+exports.ToolCallResultEventSchema = ToolCallResultEventSchema;
+exports.ToolCallSchema = ToolCallSchema;
+exports.ToolCallStartEventSchema = ToolCallStartEventSchema;
+exports.ToolMessageSchema = ToolMessageSchema;
+exports.ToolSchema = ToolSchema;
+exports.UserMessageSchema = UserMessageSchema;
 //# sourceMappingURL=index.js.map