@assistant-ui/react 0.5.91 → 0.5.93

package/dist/{edge.d.mts → runtimes/edge/EdgeRuntimeRequestOptions.d.ts}

@@ -1,58 +1,6 @@
-import { LanguageModelV1LogProbs, LanguageModelV1, LanguageModelV1ToolChoice } from '@ai-sdk/provider';
-import { JSONSchema7 } from 'json-schema';
-import { z } from 'zod';
-
-type TextContentPart = {
-    type: "text";
-    text: string;
-};
-type ImageContentPart = {
-    type: "image";
-    image: string;
-};
-type Unstable_AudioContentPart = {
-    type: "audio";
-    audio: {
-        data: string;
-        format: "mp3" | "wav";
-    };
-};
-type CoreToolCallContentPart<TArgs extends Record<string, unknown> = Record<string | number, unknown>, TResult = unknown> = {
-    type: "tool-call";
-    toolCallId: string;
-    toolName: string;
-    args: TArgs;
-    result?: TResult | undefined;
-    isError?: boolean | undefined;
-};
-type ThreadStep = {
-    /**
-     * @deprecated This field will be removed in v0.6. Submit feedback if you need this functionality.
-     */
-    logprobs?: LanguageModelV1LogProbs | undefined;
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-    } | undefined;
-};
-/** Core Message Types (without UI content parts) */
-type CoreUserContentPart = TextContentPart | ImageContentPart | Unstable_AudioContentPart;
-type CoreAssistantContentPart = TextContentPart | CoreToolCallContentPart;
-type CoreSystemMessage = {
-    role: "system";
-    content: [TextContentPart];
-};
-type CoreUserMessage = {
-    role: "user";
-    content: CoreUserContentPart[];
-};
-type CoreAssistantMessage = {
-    role: "assistant";
-    content: CoreAssistantContentPart[];
-};
-type CoreMessage = CoreSystemMessage | CoreUserMessage | CoreAssistantMessage;
-
-declare const EdgeRuntimeRequestOptionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+import { JSONSchema7 } from "json-schema";
+import { z } from "zod";
+export declare const EdgeRuntimeRequestOptionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
     system: z.ZodOptional<z.ZodString>;
     messages: z.ZodArray<z.ZodDiscriminatedUnion<"role", [z.ZodObject<{
         role: z.ZodLiteral<"system">;
@@ -229,6 +177,7 @@ declare const EdgeRuntimeRequestOptionsSchema: z.ZodObject<z.objectUtil.extendSh
         parameters: JSONSchema7;
         description?: string | undefined;
     }>, "many">>;
+    unstable_assistantMessageId: z.ZodOptional<z.ZodString>;
 }, {
     maxTokens: z.ZodOptional<z.ZodNumber>;
     temperature: z.ZodOptional<z.ZodNumber>;
@@ -294,6 +243,7 @@ declare const EdgeRuntimeRequestOptionsSchema: z.ZodObject<z.objectUtil.extendSh
         parameters: JSONSchema7;
         description?: string | undefined;
     }[] | undefined;
+    unstable_assistantMessageId?: string | undefined;
 }, {
     messages: ({
         role: "user";
@@ -347,86 +297,7 @@ declare const EdgeRuntimeRequestOptionsSchema: z.ZodObject<z.objectUtil.extendSh
         parameters: JSONSchema7;
         description?: string | undefined;
     }[] | undefined;
+    unstable_assistantMessageId?: string | undefined;
 }>;
-
-declare const LanguageModelV1CallSettingsSchema: z.ZodObject<{
-    maxTokens: z.ZodOptional<z.ZodNumber>;
-    temperature: z.ZodOptional<z.ZodNumber>;
-    topP: z.ZodOptional<z.ZodNumber>;
-    presencePenalty: z.ZodOptional<z.ZodNumber>;
-    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
-    seed: z.ZodOptional<z.ZodNumber>;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
-}, "strip", z.ZodTypeAny, {
-    maxTokens?: number | undefined;
-    temperature?: number | undefined;
-    topP?: number | undefined;
-    presencePenalty?: number | undefined;
-    frequencyPenalty?: number | undefined;
-    seed?: number | undefined;
-    headers?: Record<string, string | undefined> | undefined;
-}, {
-    maxTokens?: number | undefined;
-    temperature?: number | undefined;
-    topP?: number | undefined;
-    presencePenalty?: number | undefined;
-    frequencyPenalty?: number | undefined;
-    seed?: number | undefined;
-    headers?: Record<string, string | undefined> | undefined;
-}>;
-type LanguageModelV1CallSettings = z.infer<typeof LanguageModelV1CallSettingsSchema>;
-declare const LanguageModelConfigSchema: z.ZodObject<{
-    apiKey: z.ZodOptional<z.ZodString>;
-    baseUrl: z.ZodOptional<z.ZodString>;
-    modelName: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    apiKey?: string | undefined;
-    baseUrl?: string | undefined;
-    modelName?: string | undefined;
-}, {
-    apiKey?: string | undefined;
-    baseUrl?: string | undefined;
-    modelName?: string | undefined;
-}>;
-type LanguageModelConfig = z.infer<typeof LanguageModelConfigSchema>;
-type ToolExecuteFunction<TArgs, TResult> = (args: TArgs, context: {
-    abortSignal: AbortSignal;
-}) => TResult | Promise<TResult>;
-type Tool<TArgs extends Record<string, unknown> = Record<string | number, unknown>, TResult = unknown> = {
-    description?: string | undefined;
-    parameters: z.ZodSchema<TArgs> | JSONSchema7;
-    execute?: ToolExecuteFunction<TArgs, TResult>;
-};
-
-type FinishResult = {
-    messages: CoreMessage[];
-    metadata: {
-        /**
-         * @deprecated Use `steps` instead. This field will be removed in v0.6.
-         */
-        roundtrips: ThreadStep[];
-        steps: ThreadStep[];
-    };
-};
-type LanguageModelCreator = (config: LanguageModelConfig) => Promise<LanguageModelV1> | LanguageModelV1;
-type CreateEdgeRuntimeAPIOptions = LanguageModelV1CallSettings & {
-    model: LanguageModelV1 | LanguageModelCreator;
-    system?: string;
-    tools?: Record<string, Tool<any, any>>;
-    toolChoice?: LanguageModelV1ToolChoice;
-    onFinish?: (result: FinishResult) => void;
-};
-type GetEdgeRuntimeStreamOptions = {
-    abortSignal: AbortSignal;
-    requestData: z.infer<typeof EdgeRuntimeRequestOptionsSchema>;
-    options: CreateEdgeRuntimeAPIOptions;
-};
-declare namespace getEdgeRuntimeResponse {
-    export type { GetEdgeRuntimeStreamOptions as Options };
-}
-declare const getEdgeRuntimeResponse: (options: getEdgeRuntimeResponse.Options) => Promise<Response>;
-declare const createEdgeRuntimeAPI: (options: CreateEdgeRuntimeAPIOptions) => {
-    POST: (request: Request) => Promise<Response>;
-};
-
-export { createEdgeRuntimeAPI, getEdgeRuntimeResponse };
+export type EdgeRuntimeRequestOptions = z.infer<typeof EdgeRuntimeRequestOptionsSchema>;
+//# sourceMappingURL=EdgeRuntimeRequestOptions.d.ts.map

package/dist/runtimes/edge/EdgeRuntimeRequestOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgeRuntimeRequestOptions.d.ts","sourceRoot":"","sources":["../../../src/runtimes/edge/EdgeRuntimeRequestOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2ExB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQT,CAAC;AAEpC,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC"}

package/dist/runtimes/edge/EdgeRuntimeRequestOptions.js

@@ -0,0 +1,95 @@
+"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);
+var EdgeRuntimeRequestOptions_exports = {};
+__export(EdgeRuntimeRequestOptions_exports, {
+  EdgeRuntimeRequestOptionsSchema: () => EdgeRuntimeRequestOptionsSchema
+});
+module.exports = __toCommonJS(EdgeRuntimeRequestOptions_exports);
+var import_ModelConfigTypes = require("../../types/ModelConfigTypes");
+var import_zod = require("zod");
+const LanguageModelV1FunctionToolSchema = import_zod.z.object({
+  type: import_zod.z.literal("function"),
+  name: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  parameters: import_zod.z.custom(
+    (val) => typeof val === "object" && val !== null
+  )
+});
+const TextContentPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("text"),
+  text: import_zod.z.string()
+});
+const ImageContentPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("image"),
+  image: import_zod.z.string()
+});
+const Unstable_AudioContentPart = import_zod.z.object({
+  type: import_zod.z.literal("audio"),
+  audio: import_zod.z.object({
+    data: import_zod.z.string(),
+    format: import_zod.z.union([import_zod.z.literal("mp3"), import_zod.z.literal("wav")])
+  })
+});
+const CoreToolCallContentPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool-call"),
+  toolCallId: import_zod.z.string(),
+  toolName: import_zod.z.string(),
+  args: import_zod.z.record(import_zod.z.unknown()),
+  result: import_zod.z.unknown().optional(),
+  isError: import_zod.z.boolean().optional()
+});
+const CoreUserMessageSchema = import_zod.z.object({
+  role: import_zod.z.literal("user"),
+  content: import_zod.z.array(
+    import_zod.z.discriminatedUnion("type", [
+      TextContentPartSchema,
+      ImageContentPartSchema,
+      Unstable_AudioContentPart
+    ])
+  ).min(1)
+});
+const CoreAssistantMessageSchema = import_zod.z.object({
+  role: import_zod.z.literal("assistant"),
+  content: import_zod.z.array(
+    import_zod.z.discriminatedUnion("type", [
+      TextContentPartSchema,
+      CoreToolCallContentPartSchema
+    ])
+  ).min(1)
+});
+const CoreSystemMessageSchema = import_zod.z.object({
+  role: import_zod.z.literal("system"),
+  content: import_zod.z.tuple([TextContentPartSchema])
+});
+const CoreMessageSchema = import_zod.z.discriminatedUnion("role", [
+  CoreSystemMessageSchema,
+  CoreUserMessageSchema,
+  CoreAssistantMessageSchema
+]);
+const EdgeRuntimeRequestOptionsSchema = import_zod.z.object({
+  system: import_zod.z.string().optional(),
+  messages: import_zod.z.array(CoreMessageSchema).min(1),
+  tools: import_zod.z.array(LanguageModelV1FunctionToolSchema).optional(),
+  unstable_assistantMessageId: import_zod.z.string().optional()
+}).merge(import_ModelConfigTypes.LanguageModelV1CallSettingsSchema).merge(import_ModelConfigTypes.LanguageModelConfigSchema);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EdgeRuntimeRequestOptionsSchema
+});
+//# sourceMappingURL=EdgeRuntimeRequestOptions.js.map

package/dist/runtimes/edge/EdgeRuntimeRequestOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/runtimes/edge/EdgeRuntimeRequestOptions.ts"],"sourcesContent":["import { JSONSchema7 } from \"json-schema\";\nimport {\n  LanguageModelConfigSchema,\n  LanguageModelV1CallSettingsSchema,\n} from \"../../types/ModelConfigTypes\";\nimport { z } from \"zod\";\n\nconst LanguageModelV1FunctionToolSchema = z.object({\n  type: z.literal(\"function\"),\n  name: z.string(),\n  description: z.string().optional(),\n  parameters: z.custom<JSONSchema7>(\n    (val) => typeof val === \"object\" && val !== null,\n  ),\n});\n\nconst TextContentPartSchema = z.object({\n  type: z.literal(\"text\"),\n  text: z.string(),\n});\n\nconst ImageContentPartSchema = z.object({\n  type: z.literal(\"image\"),\n  image: z.string(),\n});\n\nconst Unstable_AudioContentPart = z.object({\n  type: z.literal(\"audio\"),\n  audio: z.object({\n    data: z.string(),\n    format: z.union([z.literal(\"mp3\"), z.literal(\"wav\")]),\n  }),\n});\n\nconst CoreToolCallContentPartSchema = z.object({\n  type: z.literal(\"tool-call\"),\n  toolCallId: z.string(),\n  toolName: z.string(),\n  args: z.record(z.unknown()),\n  result: z.unknown().optional(),\n  isError: z.boolean().optional(),\n});\n// args is required but unknown;\n\nconst CoreUserMessageSchema = z.object({\n  role: z.literal(\"user\"),\n  content: z\n    .array(\n      z.discriminatedUnion(\"type\", [\n        TextContentPartSchema,\n        ImageContentPartSchema,\n        Unstable_AudioContentPart,\n      ]),\n    )\n    .min(1),\n});\n\nconst CoreAssistantMessageSchema = z.object({\n  role: z.literal(\"assistant\"),\n  content: z\n    .array(\n      z.discriminatedUnion(\"type\", [\n        TextContentPartSchema,\n        CoreToolCallContentPartSchema,\n      ]),\n    )\n    .min(1),\n});\n\nconst CoreSystemMessageSchema = z.object({\n  role: z.literal(\"system\"),\n  content: z.tuple([TextContentPartSchema]),\n});\n\nconst CoreMessageSchema = z.discriminatedUnion(\"role\", [\n  CoreSystemMessageSchema,\n  CoreUserMessageSchema,\n  CoreAssistantMessageSchema,\n]);\n\nexport const EdgeRuntimeRequestOptionsSchema = z\n  .object({\n    system: z.string().optional(),\n    messages: z.array(CoreMessageSchema).min(1),\n    tools: z.array(LanguageModelV1FunctionToolSchema).optional(),\n    unstable_assistantMessageId: z.string().optional(),\n  })\n  .merge(LanguageModelV1CallSettingsSchema)\n  .merge(LanguageModelConfigSchema);\n\nexport type EdgeRuntimeRequestOptions = z.infer<\n  typeof EdgeRuntimeRequestOptionsSchema\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,8BAGO;AACP,iBAAkB;AAElB,MAAM,oCAAoC,aAAE,OAAO;AAAA,EACjD,MAAM,aAAE,QAAQ,UAAU;AAAA,EAC1B,MAAM,aAAE,OAAO;AAAA,EACf,aAAa,aAAE,OAAO,EAAE,SAAS;AAAA,EACjC,YAAY,aAAE;AAAA,IACZ,CAAC,QAAQ,OAAO,QAAQ,YAAY,QAAQ;AAAA,EAC9C;AACF,CAAC;AAED,MAAM,wBAAwB,aAAE,OAAO;AAAA,EACrC,MAAM,aAAE,QAAQ,MAAM;AAAA,EACtB,MAAM,aAAE,OAAO;AACjB,CAAC;AAED,MAAM,yBAAyB,aAAE,OAAO;AAAA,EACtC,MAAM,aAAE,QAAQ,OAAO;AAAA,EACvB,OAAO,aAAE,OAAO;AAClB,CAAC;AAED,MAAM,4BAA4B,aAAE,OAAO;AAAA,EACzC,MAAM,aAAE,QAAQ,OAAO;AAAA,EACvB,OAAO,aAAE,OAAO;AAAA,IACd,MAAM,aAAE,OAAO;AAAA,IACf,QAAQ,aAAE,MAAM,CAAC,aAAE,QAAQ,KAAK,GAAG,aAAE,QAAQ,KAAK,CAAC,CAAC;AAAA,EACtD,CAAC;AACH,CAAC;AAED,MAAM,gCAAgC,aAAE,OAAO;AAAA,EAC7C,MAAM,aAAE,QAAQ,WAAW;AAAA,EAC3B,YAAY,aAAE,OAAO;AAAA,EACrB,UAAU,aAAE,OAAO;AAAA,EACnB,MAAM,aAAE,OAAO,aAAE,QAAQ,CAAC;AAAA,EAC1B,QAAQ,aAAE,QAAQ,EAAE,SAAS;AAAA,EAC7B,SAAS,aAAE,QAAQ,EAAE,SAAS;AAChC,CAAC;AAGD,MAAM,wBAAwB,aAAE,OAAO;AAAA,EACrC,MAAM,aAAE,QAAQ,MAAM;AAAA,EACtB,SAAS,aACN;AAAA,IACC,aAAE,mBAAmB,QAAQ;AAAA,MAC3B;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH,EACC,IAAI,CAAC;AACV,CAAC;AAED,MAAM,6BAA6B,aAAE,OAAO;AAAA,EAC1C,MAAM,aAAE,QAAQ,WAAW;AAAA,EAC3B,SAAS,aACN;AAAA,IACC,aAAE,mBAAmB,QAAQ;AAAA,MAC3B;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH,EACC,IAAI,CAAC;AACV,CAAC;AAED,MAAM,0BAA0B,aAAE,OAAO;AAAA,EACvC,MAAM,aAAE,QAAQ,QAAQ;AAAA,EACxB,SAAS,aAAE,MAAM,CAAC,qBAAqB,CAAC;AAC1C,CAAC;AAED,MAAM,oBAAoB,aAAE,mBAAmB,QAAQ;AAAA,EACrD;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAEM,MAAM,kCAAkC,aAC5C,OAAO;AAAA,EACN,QAAQ,aAAE,OAAO,EAAE,SAAS;AAAA,EAC5B,UAAU,aAAE,MAAM,iBAAiB,EAAE,IAAI,CAAC;AAAA,EAC1C,OAAO,aAAE,MAAM,iCAAiC,EAAE,SAAS;AAAA,EAC3D,6BAA6B,aAAE,OAAO,EAAE,SAAS;AACnD,CAAC,EACA,MAAM,yDAAiC,EACvC,MAAM,iDAAyB;","names":[]}

package/dist/runtimes/edge/EdgeRuntimeRequestOptions.mjs

@@ -0,0 +1,74 @@
+import {
+  LanguageModelConfigSchema,
+  LanguageModelV1CallSettingsSchema
+} from "../../types/ModelConfigTypes";
+import { z } from "zod";
+const LanguageModelV1FunctionToolSchema = z.object({
+  type: z.literal("function"),
+  name: z.string(),
+  description: z.string().optional(),
+  parameters: z.custom(
+    (val) => typeof val === "object" && val !== null
+  )
+});
+const TextContentPartSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+});
+const ImageContentPartSchema = z.object({
+  type: z.literal("image"),
+  image: z.string()
+});
+const Unstable_AudioContentPart = z.object({
+  type: z.literal("audio"),
+  audio: z.object({
+    data: z.string(),
+    format: z.union([z.literal("mp3"), z.literal("wav")])
+  })
+});
+const CoreToolCallContentPartSchema = z.object({
+  type: z.literal("tool-call"),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  args: z.record(z.unknown()),
+  result: z.unknown().optional(),
+  isError: z.boolean().optional()
+});
+const CoreUserMessageSchema = z.object({
+  role: z.literal("user"),
+  content: z.array(
+    z.discriminatedUnion("type", [
+      TextContentPartSchema,
+      ImageContentPartSchema,
+      Unstable_AudioContentPart
+    ])
+  ).min(1)
+});
+const CoreAssistantMessageSchema = z.object({
+  role: z.literal("assistant"),
+  content: z.array(
+    z.discriminatedUnion("type", [
+      TextContentPartSchema,
+      CoreToolCallContentPartSchema
+    ])
+  ).min(1)
+});
+const CoreSystemMessageSchema = z.object({
+  role: z.literal("system"),
+  content: z.tuple([TextContentPartSchema])
+});
+const CoreMessageSchema = z.discriminatedUnion("role", [
+  CoreSystemMessageSchema,
+  CoreUserMessageSchema,
+  CoreAssistantMessageSchema
+]);
+const EdgeRuntimeRequestOptionsSchema = z.object({
+  system: z.string().optional(),
+  messages: z.array(CoreMessageSchema).min(1),
+  tools: z.array(LanguageModelV1FunctionToolSchema).optional(),
+  unstable_assistantMessageId: z.string().optional()
+}).merge(LanguageModelV1CallSettingsSchema).merge(LanguageModelConfigSchema);
+export {
+  EdgeRuntimeRequestOptionsSchema
+};
+//# sourceMappingURL=EdgeRuntimeRequestOptions.mjs.map

package/dist/runtimes/edge/EdgeRuntimeRequestOptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/runtimes/edge/EdgeRuntimeRequestOptions.ts"],"sourcesContent":["import { JSONSchema7 } from \"json-schema\";\nimport {\n  LanguageModelConfigSchema,\n  LanguageModelV1CallSettingsSchema,\n} from \"../../types/ModelConfigTypes\";\nimport { z } from \"zod\";\n\nconst LanguageModelV1FunctionToolSchema = z.object({\n  type: z.literal(\"function\"),\n  name: z.string(),\n  description: z.string().optional(),\n  parameters: z.custom<JSONSchema7>(\n    (val) => typeof val === \"object\" && val !== null,\n  ),\n});\n\nconst TextContentPartSchema = z.object({\n  type: z.literal(\"text\"),\n  text: z.string(),\n});\n\nconst ImageContentPartSchema = z.object({\n  type: z.literal(\"image\"),\n  image: z.string(),\n});\n\nconst Unstable_AudioContentPart = z.object({\n  type: z.literal(\"audio\"),\n  audio: z.object({\n    data: z.string(),\n    format: z.union([z.literal(\"mp3\"), z.literal(\"wav\")]),\n  }),\n});\n\nconst CoreToolCallContentPartSchema = z.object({\n  type: z.literal(\"tool-call\"),\n  toolCallId: z.string(),\n  toolName: z.string(),\n  args: z.record(z.unknown()),\n  result: z.unknown().optional(),\n  isError: z.boolean().optional(),\n});\n// args is required but unknown;\n\nconst CoreUserMessageSchema = z.object({\n  role: z.literal(\"user\"),\n  content: z\n    .array(\n      z.discriminatedUnion(\"type\", [\n        TextContentPartSchema,\n        ImageContentPartSchema,\n        Unstable_AudioContentPart,\n      ]),\n    )\n    .min(1),\n});\n\nconst CoreAssistantMessageSchema = z.object({\n  role: z.literal(\"assistant\"),\n  content: z\n    .array(\n      z.discriminatedUnion(\"type\", [\n        TextContentPartSchema,\n        CoreToolCallContentPartSchema,\n      ]),\n    )\n    .min(1),\n});\n\nconst CoreSystemMessageSchema = z.object({\n  role: z.literal(\"system\"),\n  content: z.tuple([TextContentPartSchema]),\n});\n\nconst CoreMessageSchema = z.discriminatedUnion(\"role\", [\n  CoreSystemMessageSchema,\n  CoreUserMessageSchema,\n  CoreAssistantMessageSchema,\n]);\n\nexport const EdgeRuntimeRequestOptionsSchema = z\n  .object({\n    system: z.string().optional(),\n    messages: z.array(CoreMessageSchema).min(1),\n    tools: z.array(LanguageModelV1FunctionToolSchema).optional(),\n    unstable_assistantMessageId: z.string().optional(),\n  })\n  .merge(LanguageModelV1CallSettingsSchema)\n  .merge(LanguageModelConfigSchema);\n\nexport type EdgeRuntimeRequestOptions = z.infer<\n  typeof EdgeRuntimeRequestOptionsSchema\n>;\n"],"mappings":"AACA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,SAAS;AAElB,MAAM,oCAAoC,EAAE,OAAO;AAAA,EACjD,MAAM,EAAE,QAAQ,UAAU;AAAA,EAC1B,MAAM,EAAE,OAAO;AAAA,EACf,aAAa,EAAE,OAAO,EAAE,SAAS;AAAA,EACjC,YAAY,EAAE;AAAA,IACZ,CAAC,QAAQ,OAAO,QAAQ,YAAY,QAAQ;AAAA,EAC9C;AACF,CAAC;AAED,MAAM,wBAAwB,EAAE,OAAO;AAAA,EACrC,MAAM,EAAE,QAAQ,MAAM;AAAA,EACtB,MAAM,EAAE,OAAO;AACjB,CAAC;AAED,MAAM,yBAAyB,EAAE,OAAO;AAAA,EACtC,MAAM,EAAE,QAAQ,OAAO;AAAA,EACvB,OAAO,EAAE,OAAO;AAClB,CAAC;AAED,MAAM,4BAA4B,EAAE,OAAO;AAAA,EACzC,MAAM,EAAE,QAAQ,OAAO;AAAA,EACvB,OAAO,EAAE,OAAO;AAAA,IACd,MAAM,EAAE,OAAO;AAAA,IACf,QAAQ,EAAE,MAAM,CAAC,EAAE,QAAQ,KAAK,GAAG,EAAE,QAAQ,KAAK,CAAC,CAAC;AAAA,EACtD,CAAC;AACH,CAAC;AAED,MAAM,gCAAgC,EAAE,OAAO;AAAA,EAC7C,MAAM,EAAE,QAAQ,WAAW;AAAA,EAC3B,YAAY,EAAE,OAAO;AAAA,EACrB,UAAU,EAAE,OAAO;AAAA,EACnB,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC;AAAA,EAC1B,QAAQ,EAAE,QAAQ,EAAE,SAAS;AAAA,EAC7B,SAAS,EAAE,QAAQ,EAAE,SAAS;AAChC,CAAC;AAGD,MAAM,wBAAwB,EAAE,OAAO;AAAA,EACrC,MAAM,EAAE,QAAQ,MAAM;AAAA,EACtB,SAAS,EACN;AAAA,IACC,EAAE,mBAAmB,QAAQ;AAAA,MAC3B;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH,EACC,IAAI,CAAC;AACV,CAAC;AAED,MAAM,6BAA6B,EAAE,OAAO;AAAA,EAC1C,MAAM,EAAE,QAAQ,WAAW;AAAA,EAC3B,SAAS,EACN;AAAA,IACC,EAAE,mBAAmB,QAAQ;AAAA,MAC3B;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH,EACC,IAAI,CAAC;AACV,CAAC;AAED,MAAM,0BAA0B,EAAE,OAAO;AAAA,EACvC,MAAM,EAAE,QAAQ,QAAQ;AAAA,EACxB,SAAS,EAAE,MAAM,CAAC,qBAAqB,CAAC;AAC1C,CAAC;AAED,MAAM,oBAAoB,EAAE,mBAAmB,QAAQ;AAAA,EACrD;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAEM,MAAM,kCAAkC,EAC5C,OAAO;AAAA,EACN,QAAQ,EAAE,OAAO,EAAE,SAAS;AAAA,EAC5B,UAAU,EAAE,MAAM,iBAAiB,EAAE,IAAI,CAAC;AAAA,EAC1C,OAAO,EAAE,MAAM,iCAAiC,EAAE,SAAS;AAAA,EAC3D,6BAA6B,EAAE,OAAO,EAAE,SAAS;AACnD,CAAC,EACA,MAAM,iCAAiC,EACvC,MAAM,yBAAyB;","names":[]}

package/dist/runtimes/edge/converters/fromCoreMessage.d.ts

@@ -0,0 +1,8 @@
+import { ThreadMessage, CoreMessage, MessageStatus, CompleteAttachment } from "../../../types";
+export declare const fromCoreMessages: (message: readonly CoreMessage[]) => ThreadMessage[];
+export declare const fromCoreMessage: (message: CoreMessage, { id, status, attachments, }?: {
+    id?: string | undefined;
+    status?: MessageStatus | undefined;
+    attachments?: readonly CompleteAttachment[] | undefined;
+}) => ThreadMessage;
+//# sourceMappingURL=fromCoreMessage.d.ts.map

package/dist/runtimes/edge/converters/fromCoreMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromCoreMessage.d.ts","sourceRoot":"","sources":["../../../../src/runtimes/edge/converters/fromCoreMessage.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EACb,WAAW,EAEX,aAAa,EACb,kBAAkB,EACnB,MAAM,gBAAgB,CAAC;AAExB,eAAO,MAAM,gBAAgB,YAClB,SAAS,WAAW,EAAE,KAC9B,aAAa,EAEf,CAAC;AAEF,eAAO,MAAM,eAAe,YACjB,WAAW;;;;MAMnB,aA4CF,CAAC"}

package/dist/runtimes/edge/converters/fromCoreMessage.js

@@ -0,0 +1,79 @@
+"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);
+var fromCoreMessage_exports = {};
+__export(fromCoreMessage_exports, {
+  fromCoreMessage: () => fromCoreMessage,
+  fromCoreMessages: () => fromCoreMessages
+});
+module.exports = __toCommonJS(fromCoreMessage_exports);
+var import_internal = require("../../../internal");
+const fromCoreMessages = (message) => {
+  return message.map((message2) => fromCoreMessage(message2));
+};
+const fromCoreMessage = (message, {
+  id = (0, import_internal.generateId)(),
+  status = { type: "complete", reason: "unknown" },
+  attachments = []
+} = {}) => {
+  const commonProps = {
+    id,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+  const role = message.role;
+  switch (role) {
+    case "assistant":
+      return {
+        ...commonProps,
+        role,
+        content: message.content.map((part) => {
+          if (part.type === "tool-call") {
+            return {
+              ...part,
+              argsText: JSON.stringify(part.args)
+            };
+          }
+          return part;
+        }),
+        status
+      };
+    case "user":
+      return {
+        ...commonProps,
+        role,
+        content: message.content,
+        attachments
+      };
+    case "system":
+      return {
+        ...commonProps,
+        role,
+        content: message.content
+      };
+    default: {
+      const unsupportedRole = role;
+      throw new Error(`Unknown message role: ${unsupportedRole}`);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromCoreMessage,
+  fromCoreMessages
+});
+//# sourceMappingURL=fromCoreMessage.js.map

package/dist/runtimes/edge/converters/fromCoreMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/runtimes/edge/converters/fromCoreMessage.ts"],"sourcesContent":["import { generateId } from \"../../../internal\";\nimport {\n  ThreadMessage,\n  CoreMessage,\n  ToolCallContentPart,\n  MessageStatus,\n  CompleteAttachment,\n} from \"../../../types\";\n\nexport const fromCoreMessages = (\n  message: readonly CoreMessage[],\n): ThreadMessage[] => {\n  return message.map((message) => fromCoreMessage(message));\n};\n\nexport const fromCoreMessage = (\n  message: CoreMessage,\n  {\n    id = generateId(),\n    status = { type: \"complete\", reason: \"unknown\" } as MessageStatus,\n    attachments = [] as readonly CompleteAttachment[],\n  } = {},\n): ThreadMessage => {\n  const commonProps = {\n    id,\n    createdAt: new Date(),\n  };\n\n  const role = message.role;\n  switch (role) {\n    case \"assistant\":\n      return {\n        ...commonProps,\n        role,\n        content: message.content.map((part) => {\n          if (part.type === \"tool-call\") {\n            return {\n              ...part,\n              argsText: JSON.stringify(part.args),\n            } satisfies ToolCallContentPart;\n          }\n          return part;\n        }),\n        status,\n      } satisfies ThreadMessage;\n\n    case \"user\":\n      return {\n        ...commonProps,\n        role,\n        content: message.content,\n        attachments,\n      } satisfies ThreadMessage;\n\n    case \"system\":\n      return {\n        ...commonProps,\n        role,\n        content: message.content,\n      } satisfies ThreadMessage;\n\n    default: {\n      const unsupportedRole: never = role;\n      throw new Error(`Unknown message role: ${unsupportedRole}`);\n    }\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAA2B;AASpB,MAAM,mBAAmB,CAC9B,YACoB;AACpB,SAAO,QAAQ,IAAI,CAACA,aAAY,gBAAgBA,QAAO,CAAC;AAC1D;AAEO,MAAM,kBAAkB,CAC7B,SACA;AAAA,EACE,SAAK,4BAAW;AAAA,EAChB,SAAS,EAAE,MAAM,YAAY,QAAQ,UAAU;AAAA,EAC/C,cAAc,CAAC;AACjB,IAAI,CAAC,MACa;AAClB,QAAM,cAAc;AAAA,IAClB;AAAA,IACA,WAAW,oBAAI,KAAK;AAAA,EACtB;AAEA,QAAM,OAAO,QAAQ;AACrB,UAAQ,MAAM;AAAA,IACZ,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH;AAAA,QACA,SAAS,QAAQ,QAAQ,IAAI,CAAC,SAAS;AACrC,cAAI,KAAK,SAAS,aAAa;AAC7B,mBAAO;AAAA,cACL,GAAG;AAAA,cACH,UAAU,KAAK,UAAU,KAAK,IAAI;AAAA,YACpC;AAAA,UACF;AACA,iBAAO;AAAA,QACT,CAAC;AAAA,QACD;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH;AAAA,QACA,SAAS,QAAQ;AAAA,QACjB;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH;AAAA,QACA,SAAS,QAAQ;AAAA,MACnB;AAAA,IAEF,SAAS;AACP,YAAM,kBAAyB;AAC/B,YAAM,IAAI,MAAM,yBAAyB,eAAe,EAAE;AAAA,IAC5D;AAAA,EACF;AACF;","names":["message"]}

package/dist/runtimes/edge/converters/fromCoreMessage.mjs

@@ -0,0 +1,54 @@
+import { generateId } from "../../../internal";
+const fromCoreMessages = (message) => {
+  return message.map((message2) => fromCoreMessage(message2));
+};
+const fromCoreMessage = (message, {
+  id = generateId(),
+  status = { type: "complete", reason: "unknown" },
+  attachments = []
+} = {}) => {
+  const commonProps = {
+    id,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+  const role = message.role;
+  switch (role) {
+    case "assistant":
+      return {
+        ...commonProps,
+        role,
+        content: message.content.map((part) => {
+          if (part.type === "tool-call") {
+            return {
+              ...part,
+              argsText: JSON.stringify(part.args)
+            };
+          }
+          return part;
+        }),
+        status
+      };
+    case "user":
+      return {
+        ...commonProps,
+        role,
+        content: message.content,
+        attachments
+      };
+    case "system":
+      return {
+        ...commonProps,
+        role,
+        content: message.content
+      };
+    default: {
+      const unsupportedRole = role;
+      throw new Error(`Unknown message role: ${unsupportedRole}`);
+    }
+  }
+};
+export {
+  fromCoreMessage,
+  fromCoreMessages
+};
+//# sourceMappingURL=fromCoreMessage.mjs.map

package/dist/runtimes/edge/converters/fromCoreMessage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/runtimes/edge/converters/fromCoreMessage.ts"],"sourcesContent":["import { generateId } from \"../../../internal\";\nimport {\n  ThreadMessage,\n  CoreMessage,\n  ToolCallContentPart,\n  MessageStatus,\n  CompleteAttachment,\n} from \"../../../types\";\n\nexport const fromCoreMessages = (\n  message: readonly CoreMessage[],\n): ThreadMessage[] => {\n  return message.map((message) => fromCoreMessage(message));\n};\n\nexport const fromCoreMessage = (\n  message: CoreMessage,\n  {\n    id = generateId(),\n    status = { type: \"complete\", reason: \"unknown\" } as MessageStatus,\n    attachments = [] as readonly CompleteAttachment[],\n  } = {},\n): ThreadMessage => {\n  const commonProps = {\n    id,\n    createdAt: new Date(),\n  };\n\n  const role = message.role;\n  switch (role) {\n    case \"assistant\":\n      return {\n        ...commonProps,\n        role,\n        content: message.content.map((part) => {\n          if (part.type === \"tool-call\") {\n            return {\n              ...part,\n              argsText: JSON.stringify(part.args),\n            } satisfies ToolCallContentPart;\n          }\n          return part;\n        }),\n        status,\n      } satisfies ThreadMessage;\n\n    case \"user\":\n      return {\n        ...commonProps,\n        role,\n        content: message.content,\n        attachments,\n      } satisfies ThreadMessage;\n\n    case \"system\":\n      return {\n        ...commonProps,\n        role,\n        content: message.content,\n      } satisfies ThreadMessage;\n\n    default: {\n      const unsupportedRole: never = role;\n      throw new Error(`Unknown message role: ${unsupportedRole}`);\n    }\n  }\n};\n"],"mappings":"AAAA,SAAS,kBAAkB;AASpB,MAAM,mBAAmB,CAC9B,YACoB;AACpB,SAAO,QAAQ,IAAI,CAACA,aAAY,gBAAgBA,QAAO,CAAC;AAC1D;AAEO,MAAM,kBAAkB,CAC7B,SACA;AAAA,EACE,KAAK,WAAW;AAAA,EAChB,SAAS,EAAE,MAAM,YAAY,QAAQ,UAAU;AAAA,EAC/C,cAAc,CAAC;AACjB,IAAI,CAAC,MACa;AAClB,QAAM,cAAc;AAAA,IAClB;AAAA,IACA,WAAW,oBAAI,KAAK;AAAA,EACtB;AAEA,QAAM,OAAO,QAAQ;AACrB,UAAQ,MAAM;AAAA,IACZ,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH;AAAA,QACA,SAAS,QAAQ,QAAQ,IAAI,CAAC,SAAS;AACrC,cAAI,KAAK,SAAS,aAAa;AAC7B,mBAAO;AAAA,cACL,GAAG;AAAA,cACH,UAAU,KAAK,UAAU,KAAK,IAAI;AAAA,YACpC;AAAA,UACF;AACA,iBAAO;AAAA,QACT,CAAC;AAAA,QACD;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH;AAAA,QACA,SAAS,QAAQ;AAAA,QACjB;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH;AAAA,QACA,SAAS,QAAQ;AAAA,MACnB;AAAA,IAEF,SAAS;AACP,YAAM,kBAAyB;AAC/B,YAAM,IAAI,MAAM,yBAAyB,eAAe,EAAE;AAAA,IAC5D;AAAA,EACF;AACF;","names":["message"]}

package/dist/runtimes/edge/converters/fromLanguageModelMessages.d.ts

@@ -0,0 +1,8 @@
+import { LanguageModelV1Message } from "@ai-sdk/provider";
+import { CoreMessage } from "../../../types";
+type fromLanguageModelMessagesOptions = {
+    mergeSteps: boolean;
+};
+export declare const fromLanguageModelMessages: (lm: LanguageModelV1Message[], { mergeSteps }: fromLanguageModelMessagesOptions) => CoreMessage[];
+export {};
+//# sourceMappingURL=fromLanguageModelMessages.d.ts.map

package/dist/runtimes/edge/converters/fromLanguageModelMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromLanguageModelMessages.d.ts","sourceRoot":"","sources":["../../../../src/runtimes/edge/converters/fromLanguageModelMessages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAElE,KAAK,gCAAgC,GAAG;IACtC,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,yBAAyB,OAChC,sBAAsB,EAAE,kBACZ,gCAAgC,KAC/C,WAAW,EAkHb,CAAC"}

package/dist/runtimes/edge/converters/fromLanguageModelMessages.js

@@ -0,0 +1,133 @@
+"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);
+var fromLanguageModelMessages_exports = {};
+__export(fromLanguageModelMessages_exports, {
+  fromLanguageModelMessages: () => fromLanguageModelMessages
+});
+module.exports = __toCommonJS(fromLanguageModelMessages_exports);
+const fromLanguageModelMessages = (lm, { mergeSteps }) => {
+  const messages = [];
+  for (const lmMessage of lm) {
+    const role = lmMessage.role;
+    switch (role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content: [
+            {
+              type: "text",
+              text: lmMessage.content
+            }
+          ]
+        });
+        break;
+      }
+      case "user": {
+        messages.push({
+          role: "user",
+          content: lmMessage.content.map((part) => {
+            const type = part.type;
+            switch (type) {
+              case "text": {
+                return {
+                  type: "text",
+                  text: part.text
+                };
+              }
+              case "image": {
+                if (part.image instanceof URL) {
+                  return {
+                    type: "image",
+                    image: part.image.href
+                  };
+                }
+                throw new Error("Only images with URL data are supported");
+              }
+              case "file": {
+                throw new Error("File content parts are not supported");
+              }
+              default: {
+                const unhandledType = type;
+                throw new Error(`Unknown content part type: ${unhandledType}`);
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        const newContent = lmMessage.content.map((part) => {
+          if (part.type === "tool-call") {
+            return {
+              type: "tool-call",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              argsText: JSON.stringify(part.args),
+              args: part.args
+            };
+          }
+          return part;
+        });
+        if (mergeSteps) {
+          const previousMessage = messages[messages.length - 1];
+          if (previousMessage?.role === "assistant") {
+            previousMessage.content.push(...newContent);
+            break;
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: newContent
+        });
+        break;
+      }
+      case "tool": {
+        const previousMessage = messages[messages.length - 1];
+        if (previousMessage?.role !== "assistant")
+          throw new Error(
+            "A tool message must be preceded by an assistant message."
+          );
+        for (const tool of lmMessage.content) {
+          const toolCall = previousMessage.content.find(
+            (c) => c.type === "tool-call" && c.toolCallId === tool.toolCallId
+          );
+          if (!toolCall)
+            throw new Error("Received tool result for an unknown tool call.");
+          if (toolCall.toolName !== tool.toolName)
+            throw new Error("Tool call name mismatch.");
+          toolCall.result = tool.result;
+          if (tool.isError) {
+            toolCall.isError = true;
+          }
+        }
+        break;
+      }
+      default: {
+        const unhandledRole = role;
+        throw new Error(`Unknown message role: ${unhandledRole}`);
+      }
+    }
+  }
+  return messages;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromLanguageModelMessages
+});
+//# sourceMappingURL=fromLanguageModelMessages.js.map