@workglow/ai 0.2.8 → 0.2.9

package/dist/bun.js

@@ -322,6 +322,7 @@ class QueuedExecutionStrategy {
   concurrency;
   autoCreate;
   initPromise = null;
+  limiter;
   constructor(queueName, concurrency = 1, autoCreate = true) {
     this.queueName = queueName;
     this.concurrency = concurrency;
@@ -359,8 +360,42 @@ class QueuedExecutionStrategy {
   }
   abort() {}
   async* executeStream(jobInput, context, runnerId) {
-    const result = await this.execute(jobInput, context, runnerId);
-    yield { type: "finish", data: result };
+    if (context.signal.aborted) {
+      throw context.signal.reason ?? new AbortSignalJobError2("The operation was aborted");
+    }
+    await this.ensureQueue();
+    const limiter = this.limiter;
+    if (!limiter) {
+      throw new TaskConfigurationError(`QueuedExecutionStrategy: limiter was not initialized for queue "${this.queueName}"`);
+    }
+    await this.acquireLimiterSlot(limiter, context.signal);
+    try {
+      const job = new AiJob({
+        queueName: jobInput.aiProvider,
+        jobRunId: runnerId,
+        input: jobInput
+      });
+      yield* job.executeStream(jobInput, {
+        signal: context.signal,
+        updateProgress: context.updateProgress
+      });
+    } finally {
+      await limiter.recordJobCompletion();
+    }
+  }
+  async acquireLimiterSlot(limiter, signal) {
+    const poll = async () => {
+      while (!await limiter.canProceed()) {
+        if (signal.aborted) {
+          throw signal.reason ?? new AbortSignalJobError2("The operation was aborted");
+        }
+        const next = await limiter.getNextAvailableTime();
+        const delay = Math.max(0, next.getTime() - Date.now());
+        await new Promise((resolve) => setTimeout(resolve, Math.min(delay, 50)));
+      }
+    };
+    await poll();
+    await limiter.recordJobStart();
   }
   ensureQueue() {
     if (!this.initPromise) {
@@ -378,6 +413,7 @@ class QueuedExecutionStrategy {
       if (!existing.server.isRunning()) {
         await existing.server.start();
       }
+      this.limiter = existing.server.limiter;
       return existing;
     }
     if (!this.autoCreate) {
@@ -385,10 +421,11 @@ class QueuedExecutionStrategy {
     }
     const storage = new InMemoryQueueStorage(this.queueName);
     await storage.setupDatabase();
+    this.limiter = new ConcurrencyLimiter(this.concurrency);
     const server = new JobQueueServer(AiJob, {
       storage,
       queueName: this.queueName,
-      limiter: new ConcurrencyLimiter(this.concurrency)
+      limiter: this.limiter
     });
     const client = new JobQueueClient({
       storage,
@@ -412,6 +449,7 @@ class QueuedExecutionStrategy {
           if (!raced.server.isRunning()) {
             await raced.server.start();
           }
+          this.limiter = raced.server.limiter;
           return raced;
         }
       }
@@ -800,8 +838,8 @@ class QueuedAiProvider extends AiProvider {
 // src/task/index.ts
 import { TaskRegistry } from "@workglow/task-graph";
 
-// src/task/BackgroundRemovalTask.ts
-import { CreateWorkflow, Workflow } from "@workglow/task-graph";
+// src/task/AiChatTask.ts
+import { TaskConfigSchema as TaskConfigSchema2 } from "@workglow/task-graph";
 
 // src/task/base/AiTaskSchemas.ts
 var TypeLanguage = (annotations = {}) => ({
@@ -960,8 +998,8 @@ var TypeCategory = {
   description: "Classification category with label and score"
 };
 
-// src/task/base/AiVisionTask.ts
-import { convertImageDataToUseableForm } from "@workglow/util/media";
+// src/task/base/StreamingAiTask.ts
+import { getStreamingPorts, TaskConfigurationError as TaskConfigurationError3 } from "@workglow/task-graph";
 
 // src/task/base/AiTask.ts
 import {
@@ -1147,7 +1185,393 @@ class AiTask extends Task {
   }
 }
 
+// src/task/base/StreamingAiTask.ts
+class StreamingAiTask extends AiTask {
+  static type = "StreamingAiTask";
+  async* executeStream(input, context) {
+    const model = input.model;
+    if (!model || typeof model !== "object") {
+      throw new TaskConfigurationError3("StreamingAiTask: Model was not resolved to ModelConfig - this indicates a bug in the resolution system");
+    }
+    const jobInput = await this.getJobInput(input);
+    const strategy = getAiProviderRegistry().getStrategy(model);
+    const outSchema = this.outputSchema();
+    const ports = getStreamingPorts(outSchema);
+    let defaultPort = "text";
+    if (ports.length > 0) {
+      defaultPort = ports[0].port;
+    } else {
+      if (typeof outSchema === "object" && outSchema.properties) {
+        const firstProp = Object.keys(outSchema.properties)[0];
+        if (firstProp)
+          defaultPort = firstProp;
+      }
+    }
+    for await (const event of strategy.executeStream(jobInput, context, this.runConfig.runnerId)) {
+      if (event.type === "text-delta") {
+        yield { ...event, port: event.port ?? defaultPort };
+      } else if (event.type === "object-delta") {
+        yield { ...event, port: event.port ?? defaultPort };
+      } else {
+        yield event;
+      }
+    }
+  }
+}
+
+// src/task/ChatMessage.ts
+var ContentBlockTextSchema = {
+  type: "object",
+  properties: {
+    type: { type: "string", enum: ["text"] },
+    text: { type: "string" }
+  },
+  required: ["type", "text"],
+  additionalProperties: false
+};
+var ContentBlockImageSchema = {
+  type: "object",
+  properties: {
+    type: { type: "string", enum: ["image"] },
+    mimeType: { type: "string" },
+    data: { type: "string" }
+  },
+  required: ["type", "mimeType", "data"],
+  additionalProperties: false
+};
+var ContentBlockToolUseSchema = {
+  type: "object",
+  properties: {
+    type: { type: "string", enum: ["tool_use"] },
+    id: { type: "string" },
+    name: { type: "string" },
+    input: { type: "object", additionalProperties: true }
+  },
+  required: ["type", "id", "name", "input"],
+  additionalProperties: false
+};
+var ContentBlockToolResultSchema = {
+  type: "object",
+  properties: {
+    type: { type: "string", enum: ["tool_result"] },
+    tool_use_id: { type: "string" },
+    content: {
+      type: "array",
+      items: { $ref: "#/definitions/ContentBlock" }
+    },
+    is_error: { type: "boolean" }
+  },
+  required: ["type", "tool_use_id", "content"],
+  additionalProperties: false
+};
+var ContentBlockSchema = {
+  oneOf: [
+    ContentBlockTextSchema,
+    ContentBlockImageSchema,
+    ContentBlockToolUseSchema,
+    ContentBlockToolResultSchema
+  ],
+  definitions: {
+    ContentBlock: {
+      oneOf: [
+        ContentBlockTextSchema,
+        ContentBlockImageSchema,
+        ContentBlockToolUseSchema,
+        ContentBlockToolResultSchema
+      ]
+    }
+  },
+  title: "ContentBlock",
+  description: "A single content block within a chat message"
+};
+var ChatMessageSchema = {
+  type: "object",
+  properties: {
+    role: { type: "string", enum: ["user", "assistant", "tool", "system"] },
+    content: {
+      type: "array",
+      items: ContentBlockSchema
+    }
+  },
+  required: ["role", "content"],
+  additionalProperties: false,
+  title: "ChatMessage",
+  description: "A single chat message with role and structured content blocks"
+};
+function isContentBlock(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  switch (v.type) {
+    case "text":
+      return typeof v.text === "string";
+    case "image":
+      return typeof v.mimeType === "string" && typeof v.data === "string";
+    case "tool_use":
+      return typeof v.id === "string" && typeof v.name === "string" && v.input !== null && typeof v.input === "object";
+    case "tool_result":
+      return typeof v.tool_use_id === "string" && Array.isArray(v.content) && v.content.every(isContentBlock);
+    default:
+      return false;
+  }
+}
+function isChatMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  const validRole = v.role === "user" || v.role === "assistant" || v.role === "tool" || v.role === "system";
+  return validRole && Array.isArray(v.content) && v.content.every(isContentBlock);
+}
+function textMessage(role, text) {
+  return { role, content: [{ type: "text", text }] };
+}
+
+// src/task/AiChatTask.ts
+import { resolveHumanConnector } from "@workglow/util";
+var modelSchema = TypeModel("model:AiChatTask");
+var chatConnectorContentSchema = {
+  type: "object",
+  properties: {
+    content: {
+      type: "string",
+      title: "Message",
+      description: "Your reply (leave blank to end the conversation)"
+    }
+  },
+  additionalProperties: false
+};
+var AiChatInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema,
+    prompt: {
+      oneOf: [
+        { type: "string", title: "Prompt", description: "The initial user message" },
+        {
+          type: "array",
+          title: "Prompt",
+          description: "The initial user message as structured content blocks",
+          items: ContentBlockSchema
+        }
+      ],
+      title: "Prompt",
+      description: "The first user message to start the conversation"
+    },
+    messages: {
+      type: "array",
+      title: "Messages",
+      description: "Conversation history (managed internally by the chat loop; not a user-facing input)",
+      items: ChatMessageSchema,
+      "x-ui-hidden": true
+    },
+    systemPrompt: {
+      type: "string",
+      title: "System Prompt",
+      description: "Optional system instructions for the model"
+    },
+    maxTokens: {
+      type: "number",
+      title: "Max Tokens",
+      description: "Per-turn token limit",
+      minimum: 1,
+      "x-ui-group": "Configuration"
+    },
+    temperature: {
+      type: "number",
+      title: "Temperature",
+      description: "Sampling temperature",
+      minimum: 0,
+      maximum: 2,
+      "x-ui-group": "Configuration"
+    },
+    maxIterations: {
+      type: "number",
+      title: "Max Iterations",
+      description: "Safety cap on conversation turns",
+      minimum: 1,
+      default: 100,
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["model", "prompt"],
+  additionalProperties: false
+};
+var AiChatOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "Last assistant response",
+      "x-stream": "append"
+    },
+    messages: {
+      type: "array",
+      title: "Messages",
+      description: "Full conversation history",
+      items: ChatMessageSchema,
+      "x-stream": "object"
+    },
+    iterations: {
+      type: "number",
+      title: "Iterations",
+      description: "Number of completed turns"
+    }
+  },
+  required: ["text", "messages", "iterations"],
+  additionalProperties: false
+};
+
+class AiChatTask extends StreamingAiTask {
+  static type = "AiChatTask";
+  static category = "AI Chat";
+  static title = "AI Chat";
+  static description = "Multi-turn chat with a language model, using a human connector to collect user input between turns.";
+  static cacheable = false;
+  static configSchema() {
+    return {
+      type: "object",
+      properties: {
+        ...TaskConfigSchema2["properties"]
+      },
+      additionalProperties: false
+    };
+  }
+  static inputSchema() {
+    return AiChatInputSchema;
+  }
+  static outputSchema() {
+    return AiChatOutputSchema;
+  }
+  _sessionId;
+  async getJobInput(input) {
+    const model = input.model;
+    if (!this._sessionId) {
+      this._sessionId = getAiProviderRegistry().createSession(model.provider, model);
+    }
+    return {
+      taskType: "AiChatTask",
+      aiProvider: model.provider,
+      taskInput: input,
+      sessionId: this._sessionId
+    };
+  }
+  async* executeStream(input, context) {
+    this._sessionId = undefined;
+    const model = input.model;
+    if (!model || typeof model !== "object") {
+      throw new Error("AiChatTask: model was not resolved to ModelConfig");
+    }
+    const connector = resolveHumanConnector(context);
+    const history = [];
+    if (input.systemPrompt) {
+      history.push({ role: "system", content: [{ type: "text", text: input.systemPrompt }] });
+    }
+    const firstUserBlocks = typeof input.prompt === "string" ? [{ type: "text", text: input.prompt }] : input.prompt;
+    history.push({ role: "user", content: firstUserBlocks });
+    const workingInput = { ...input, messages: history };
+    await this.getJobInput(workingInput);
+    const strategy = getAiProviderRegistry().getStrategy(model);
+    const maxIterations = input.maxIterations ?? 100;
+    if (context.resourceScope && this._sessionId) {
+      const sessionId = this._sessionId;
+      context.resourceScope.register(`ai:session:${sessionId}`, async () => {
+        await getAiProviderRegistry().disposeSession(model.provider, sessionId);
+      });
+    }
+    yield {
+      type: "object-delta",
+      port: "messages",
+      objectDelta: [...history]
+    };
+    let iterations = 0;
+    let lastAssistantText = "";
+    for (let turn = 0;turn < maxIterations; turn++) {
+      const perTurnInput = { ...input, messages: [...history] };
+      const turnJobInput = await this.getJobInput(perTurnInput);
+      let assistantText = "";
+      for await (const event of strategy.executeStream(turnJobInput, context, this.runConfig.runnerId)) {
+        if (event.type === "text-delta") {
+          assistantText += event.textDelta;
+          yield {
+            ...event,
+            port: event.port ?? "text"
+          };
+        } else if (event.type === "finish") {} else {
+          yield event;
+        }
+      }
+      iterations++;
+      lastAssistantText = assistantText;
+      const assistantMsg = {
+        role: "assistant",
+        content: [{ type: "text", text: assistantText }]
+      };
+      history.push(assistantMsg);
+      yield {
+        type: "object-delta",
+        port: "messages",
+        objectDelta: [assistantMsg]
+      };
+      const request = {
+        requestId: crypto.randomUUID(),
+        targetHumanId: "default",
+        kind: "elicit",
+        message: "",
+        contentSchema: chatConnectorContentSchema,
+        contentData: undefined,
+        expectsResponse: true,
+        mode: "multi-turn",
+        metadata: { iteration: turn, taskId: this.id }
+      };
+      const response = await connector.send(request, context.signal);
+      if (response.action === "cancel" || response.action === "decline")
+        break;
+      const raw = response.content?.content;
+      let userContent;
+      if (typeof raw === "string") {
+        const text = raw.trim();
+        userContent = text.length > 0 ? [{ type: "text", text: raw }] : [];
+      } else if (Array.isArray(raw)) {
+        userContent = raw;
+      } else {
+        userContent = [];
+      }
+      if (userContent.length === 0)
+        break;
+      const userMsg = { role: "user", content: userContent };
+      history.push(userMsg);
+      yield {
+        type: "object-delta",
+        port: "messages",
+        objectDelta: [userMsg]
+      };
+    }
+    yield {
+      type: "finish",
+      data: {
+        text: lastAssistantText,
+        messages: [...history],
+        iterations
+      }
+    };
+  }
+  async execute(input, context) {
+    let result;
+    for await (const event of this.executeStream(input, context)) {
+      if (event.type === "finish") {
+        result = event.data;
+      }
+    }
+    return result;
+  }
+}
+
+// src/task/BackgroundRemovalTask.ts
+import { CreateWorkflow, Workflow } from "@workglow/task-graph";
+
 // src/task/base/AiVisionTask.ts
+import { convertImageDataToUseableForm } from "@workglow/util/media";
 class AiVisionTask extends AiTask {
   static type = "AiVisionTask";
   async getJobInput(input) {
@@ -1168,7 +1592,7 @@ class AiVisionTask extends AiTask {
 }
 
 // src/task/BackgroundRemovalTask.ts
-var modelSchema = TypeModel("model:BackgroundRemovalTask");
+var modelSchema2 = TypeModel("model:BackgroundRemovalTask");
 var processedImageSchema = {
   type: "string",
   contentEncoding: "base64",
@@ -1180,7 +1604,7 @@ var BackgroundRemovalInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema
+    model: modelSchema2
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -1224,7 +1648,7 @@ import { CreateWorkflow as CreateWorkflow2, Workflow as Workflow2 } from "@workg
 import {
   TypedArraySchema
 } from "@workglow/util/schema";
-var modelSchema2 = TypeModel("model:TextEmbeddingTask");
+var modelSchema3 = TypeModel("model:TextEmbeddingTask");
 var TextEmbeddingInputSchema = {
   type: "object",
   properties: {
@@ -1233,7 +1657,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema2
+    model: modelSchema3
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2002,7 +2426,7 @@ import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9
 
 // src/task/CountTokensTask.ts
 import { CreateWorkflow as CreateWorkflow8, Workflow as Workflow8 } from "@workglow/task-graph";
-var modelSchema3 = TypeModel("model");
+var modelSchema4 = TypeModel("model");
 var CountTokensInputSchema = {
   type: "object",
   properties: {
@@ -2011,7 +2435,7 @@ var CountTokensInputSchema = {
       title: "Text",
       description: "The text to count tokens for"
     },
-    model: modelSchema3
+    model: modelSchema4
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2055,7 +2479,7 @@ var ContextFormat = {
   MARKDOWN: "markdown",
   JSON: "json"
 };
-var modelSchema4 = TypeModel("model", {
+var modelSchema5 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting (optional, falls back to estimation)"
 });
@@ -2119,7 +2543,7 @@ var inputSchema6 = {
 
 `
     },
-    model: modelSchema4
+    model: modelSchema5
   },
   required: ["chunks"],
   additionalProperties: false
@@ -2353,7 +2777,7 @@ import { CreateWorkflow as CreateWorkflow12, Task as Task8, Workflow as Workflow
 
 // src/task/TextNamedEntityRecognitionTask.ts
 import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
-var modelSchema5 = TypeModel("model:TextNamedEntityRecognitionTask");
+var modelSchema6 = TypeModel("model:TextNamedEntityRecognitionTask");
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
   properties: {
@@ -2372,7 +2796,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema5
+    model: modelSchema6
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2431,44 +2855,7 @@ Workflow10.prototype.textNamedEntityRecognition = CreateWorkflow10(TextNamedEnti
 
 // src/task/TextSummaryTask.ts
 import { CreateWorkflow as CreateWorkflow11, Workflow as Workflow11 } from "@workglow/task-graph";
-
-// src/task/base/StreamingAiTask.ts
-import { getStreamingPorts, TaskConfigurationError as TaskConfigurationError3 } from "@workglow/task-graph";
-class StreamingAiTask extends AiTask {
-  static type = "StreamingAiTask";
-  async* executeStream(input, context) {
-    const model = input.model;
-    if (!model || typeof model !== "object") {
-      throw new TaskConfigurationError3("StreamingAiTask: Model was not resolved to ModelConfig - this indicates a bug in the resolution system");
-    }
-    const jobInput = await this.getJobInput(input);
-    const strategy = getAiProviderRegistry().getStrategy(model);
-    const outSchema = this.outputSchema();
-    const ports = getStreamingPorts(outSchema);
-    let defaultPort = "text";
-    if (ports.length > 0) {
-      defaultPort = ports[0].port;
-    } else {
-      if (typeof outSchema === "object" && outSchema.properties) {
-        const firstProp = Object.keys(outSchema.properties)[0];
-        if (firstProp)
-          defaultPort = firstProp;
-      }
-    }
-    for await (const event of strategy.executeStream(jobInput, context, this.runConfig.runnerId)) {
-      if (event.type === "text-delta") {
-        yield { ...event, port: event.port ?? defaultPort };
-      } else if (event.type === "object-delta") {
-        yield { ...event, port: event.port ?? defaultPort };
-      } else {
-        yield event;
-      }
-    }
-  }
-}
-
-// src/task/TextSummaryTask.ts
-var modelSchema6 = TypeModel("model:TextSummaryTask");
+var modelSchema7 = TypeModel("model:TextSummaryTask");
 var TextSummaryInputSchema = {
   type: "object",
   properties: {
@@ -2477,7 +2864,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     },
-    model: modelSchema6
+    model: modelSchema7
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2831,11 +3218,11 @@ Workflow13.prototype.documentUpsert = CreateWorkflow13(DocumentUpsertTask);
 
 // src/task/DownloadModelTask.ts
 import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
-var modelSchema7 = TypeModel("model");
+var modelSchema8 = TypeModel("model");
 var DownloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema7
+    model: modelSchema8
   },
   required: ["model"],
   additionalProperties: false
@@ -2843,7 +3230,7 @@ var DownloadModelInputSchema = {
 var DownloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema7
+    model: modelSchema8
   },
   required: ["model"],
   additionalProperties: false
@@ -2901,7 +3288,7 @@ Workflow14.prototype.downloadModel = CreateWorkflow14(DownloadModelTask);
 
 // src/task/FaceDetectorTask.ts
 import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
-var modelSchema8 = TypeModel("model:FaceDetectorTask");
+var modelSchema9 = TypeModel("model:FaceDetectorTask");
 var TypeBoundingBox2 = {
   type: "object",
   properties: {
@@ -2974,7 +3361,7 @@ var FaceDetectorInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema8,
+    model: modelSchema9,
     minDetectionConfidence: {
       type: "number",
       minimum: 0,
@@ -3032,7 +3419,7 @@ Workflow15.prototype.faceDetector = CreateWorkflow15(FaceDetectorTask);
 
 // src/task/FaceLandmarkerTask.ts
 import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
-var modelSchema9 = TypeModel("model:FaceLandmarkerTask");
+var modelSchema10 = TypeModel("model:FaceLandmarkerTask");
 var TypeLandmark = {
   type: "object",
   properties: {
@@ -3104,7 +3491,7 @@ var FaceLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema9,
+    model: modelSchema10,
     numFaces: {
       type: "number",
       minimum: 1,
@@ -3194,7 +3581,7 @@ Workflow16.prototype.faceLandmarker = CreateWorkflow16(FaceLandmarkerTask);
 
 // src/task/GestureRecognizerTask.ts
 import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
-var modelSchema10 = TypeModel("model:GestureRecognizerTask");
+var modelSchema11 = TypeModel("model:GestureRecognizerTask");
 var TypeLandmark2 = {
   type: "object",
   properties: {
@@ -3286,7 +3673,7 @@ var GestureRecognizerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema10,
+    model: modelSchema11,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3362,7 +3749,7 @@ Workflow17.prototype.gestureRecognizer = CreateWorkflow17(GestureRecognizerTask)
 
 // src/task/HandLandmarkerTask.ts
 import { CreateWorkflow as CreateWorkflow18, Workflow as Workflow18 } from "@workglow/task-graph";
-var modelSchema11 = TypeModel("model:HandLandmarkerTask");
+var modelSchema12 = TypeModel("model:HandLandmarkerTask");
 var TypeLandmark3 = {
   type: "object",
   properties: {
@@ -3431,7 +3818,7 @@ var HandLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema11,
+    model: modelSchema12,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3514,7 +3901,7 @@ import {
 } from "@workglow/knowledge-base";
 import { CreateWorkflow as CreateWorkflow19, Task as Task10, Workflow as Workflow19 } from "@workglow/task-graph";
 import { uuid4 } from "@workglow/util";
-var modelSchema12 = TypeModel("model", {
+var modelSchema13 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting"
 });
@@ -3560,7 +3947,7 @@ var inputSchema9 = {
       description: "Strategy for chunking",
       default: "hierarchical"
     },
-    model: modelSchema12
+    model: modelSchema13
   },
   required: ["doc_id", "documentTree"],
   additionalProperties: false
@@ -4005,12 +4392,12 @@ Workflow21.prototype.kbToDocuments = CreateWorkflow21(KbToDocumentsTask);
 
 // src/task/ImageClassificationTask.ts
 import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
-var modelSchema13 = TypeModel("model:ImageClassificationTask");
+var modelSchema14 = TypeModel("model:ImageClassificationTask");
 var ImageClassificationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema13,
+    model: modelSchema14,
     categories: {
       type: "array",
       items: {
@@ -4071,12 +4458,12 @@ import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@wor
 import {
   TypedArraySchema as TypedArraySchema7
 } from "@workglow/util/schema";
-var modelSchema14 = TypeModel("model:ImageEmbeddingTask");
+var modelSchema15 = TypeModel("model:ImageEmbeddingTask");
 var ImageEmbeddingInputSchema = {
   type: "object",
   properties: {
     image: TypeSingleOrArray(TypeImageInput),
-    model: modelSchema14
+    model: modelSchema15
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -4112,12 +4499,12 @@ Workflow23.prototype.imageEmbedding = CreateWorkflow23(ImageEmbeddingTask);
 
 // src/task/ImageSegmentationTask.ts
 import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
-var modelSchema15 = TypeModel("model:ImageSegmentationTask");
+var modelSchema16 = TypeModel("model:ImageSegmentationTask");
 var ImageSegmentationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema15,
+    model: modelSchema16,
     threshold: {
       type: "number",
       title: "Threshold",
@@ -4200,7 +4587,7 @@ Workflow24.prototype.imageSegmentation = CreateWorkflow24(ImageSegmentationTask)
 
 // src/task/ImageToTextTask.ts
 import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
-var modelSchema16 = TypeModel("model:ImageToTextTask");
+var modelSchema17 = TypeModel("model:ImageToTextTask");
 var generatedTextSchema = {
   type: "string",
   title: "Text",
@@ -4210,7 +4597,7 @@ var ImageToTextInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema16,
+    model: modelSchema17,
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -4255,11 +4642,11 @@ Workflow25.prototype.imageToText = CreateWorkflow25(ImageToTextTask);
 
 // src/task/ModelInfoTask.ts
 import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
-var modelSchema17 = TypeModel("model");
+var modelSchema18 = TypeModel("model");
 var ModelInfoInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema17,
+    model: modelSchema18,
     detail: {
       type: "string",
       enum: ["cached_status", "files", "files_with_metadata", "dimensions"],
@@ -4272,7 +4659,7 @@ var ModelInfoInputSchema = {
 var ModelInfoOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema17,
+    model: modelSchema18,
     is_local: { type: "boolean" },
     is_remote: { type: "boolean" },
     supports_browser: { type: "boolean" },
@@ -4428,7 +4815,7 @@ Workflow27.prototype.modelSearch = CreateWorkflow27(ModelSearchTask);
 
 // src/task/ObjectDetectionTask.ts
 import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
-var modelSchema18 = TypeModel("model:ObjectDetectionTask");
+var modelSchema19 = TypeModel("model:ObjectDetectionTask");
 var detectionSchema = {
   type: "object",
   properties: {
@@ -4453,7 +4840,7 @@ var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema18,
+    model: modelSchema19,
     labels: {
       type: "array",
       items: {
@@ -4511,7 +4898,7 @@ Workflow28.prototype.objectDetection = CreateWorkflow28(ObjectDetectionTask);
 
 // src/task/PoseLandmarkerTask.ts
 import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
-var modelSchema19 = TypeModel("model:PoseLandmarkerTask");
+var modelSchema20 = TypeModel("model:PoseLandmarkerTask");
 var TypePoseLandmark = {
   type: "object",
   properties: {
@@ -4590,7 +4977,7 @@ var PoseLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema19,
+    model: modelSchema20,
     numPoses: {
       type: "number",
       minimum: 1,
@@ -4889,7 +5276,7 @@ import { CreateWorkflow as CreateWorkflow32, Task as Task15, Workflow as Workflo
 
 // src/task/TextClassificationTask.ts
 import { CreateWorkflow as CreateWorkflow31, Workflow as Workflow31 } from "@workglow/task-graph";
-var modelSchema20 = TypeModel("model:TextClassificationTask");
+var modelSchema21 = TypeModel("model:TextClassificationTask");
 var TextClassificationInputSchema = {
   type: "object",
   properties: {
@@ -4916,7 +5303,7 @@ var TextClassificationInputSchema = {
       description: "The maximum number of categories to return",
       "x-ui-group": "Configuration"
     },
-    model: modelSchema20
+    model: modelSchema21
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5299,12 +5686,13 @@ var structuralParser = (input, config) => {
 Workflow33.prototype.structuralParser = CreateWorkflow33(StructuralParserTask);
 
 // src/task/StructuredGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
-var modelSchema21 = TypeModel("model:StructuredGenerationTask");
+import { CreateWorkflow as CreateWorkflow34, TaskConfigurationError as TaskConfigurationError4, TaskError, Workflow as Workflow34 } from "@workglow/task-graph";
+import { compileSchema as compileSchema2 } from "@workglow/util/schema";
+var modelSchema22 = TypeModel("model:StructuredGenerationTask");
 var StructuredGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema21,
+    model: modelSchema22,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5331,6 +5719,15 @@ var StructuredGenerationInputSchema = {
       minimum: 0,
       maximum: 2,
       "x-ui-group": "Configuration"
+    },
+    maxRetries: {
+      type: "integer",
+      title: "Max Retries",
+      description: "Number of times to re-prompt the model with validation errors when its output doesn't match the schema. 0 disables retries (fail on first mismatch).",
+      minimum: 0,
+      maximum: 10,
+      default: 2,
+      "x-ui-group": "Configuration"
     }
   },
   required: ["model", "prompt", "outputSchema"],
@@ -5352,17 +5749,111 @@ var StructuredGenerationOutputSchema = {
   additionalProperties: false
 };
 
+class StructuredOutputValidationError extends TaskError {
+  static type = "StructuredOutputValidationError";
+  attempts;
+  constructor(attempts) {
+    const last = attempts[attempts.length - 1];
+    const summary = last?.errors.map((e) => `${e.path || "/"}: ${e.message}`).join("; ") ?? "";
+    super(`StructuredGenerationTask: model output failed validation after ${attempts.length} attempt(s). ` + `Last errors: ${summary}`);
+    this.attempts = attempts;
+  }
+}
+function validationErrorsFromSchemaNode(result) {
+  return result.errors.map((e) => ({ path: e.data.pointer || "", message: e.message }));
+}
+function buildRetryPrompt(originalPrompt, errors) {
+  const errorList = errors.map((e) => `  - ${e.path || "/"}: ${e.message}`).join(`
+`);
+  return `${originalPrompt}
+
+` + `Your previous response did not conform to the required JSON schema. ` + `Validation errors:
+${errorList}
+
+` + `Please respond again with a JSON object that satisfies the schema. ` + `Output ONLY the JSON object, no other text.`;
+}
+
 class StructuredGenerationTask extends StreamingAiTask {
   static type = "StructuredGenerationTask";
   static category = "AI Text Model";
   static title = "Structured Generation";
-  static description = "Generates structured JSON output conforming to a provided schema using language models";
+  static description = "Generates structured JSON output conforming to a provided schema using language models, with automatic validation and retry on mismatch";
   static inputSchema() {
     return StructuredGenerationInputSchema;
   }
   static outputSchema() {
     return StructuredGenerationOutputSchema;
   }
+  async* executeStream(input, context) {
+    let validator;
+    try {
+      validator = compileSchema2(input.outputSchema);
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      const configErr = new TaskConfigurationError4(`StructuredGenerationTask: invalid outputSchema \u2014 ${msg}`);
+      configErr.taskType = this.type;
+      configErr.taskId = this.id;
+      throw configErr;
+    }
+    const maxRetries = Math.max(0, input.maxRetries ?? 2);
+    const maxAttempts = maxRetries + 1;
+    const attempts = [];
+    let currentInput = input;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      let lastObject;
+      for await (const event of super.executeStream(currentInput, context)) {
+        if (event.type === "object-delta" && event.port === "object") {
+          const delta = event.objectDelta;
+          if (delta && !Array.isArray(delta)) {
+            lastObject = delta;
+          }
+          yield event;
+        } else if (event.type === "finish") {
+          const data = event.data;
+          const finalObject = data?.object ?? lastObject ?? {};
+          const result = validator.validate(finalObject);
+          if (result.valid) {
+            yield {
+              type: "finish",
+              data: { object: finalObject }
+            };
+            return;
+          }
+          const errors = validationErrorsFromSchemaNode(result);
+          attempts.push({ attempt, errors, object: finalObject });
+          lastObject = finalObject;
+          break;
+        } else {
+          yield event;
+        }
+      }
+      if (attempt < maxAttempts) {
+        yield {
+          type: "object-delta",
+          port: "object",
+          objectDelta: {}
+        };
+        const lastErrors = attempts[attempts.length - 1].errors;
+        currentInput = {
+          ...input,
+          prompt: buildRetryPrompt(input.prompt, lastErrors)
+        };
+      }
+    }
+    const err = new StructuredOutputValidationError(attempts);
+    err.taskType = this.type;
+    err.taskId = this.id;
+    throw err;
+  }
+  async execute(input, context) {
+    let result;
+    for await (const event of this.executeStream(input, context)) {
+      if (event.type === "finish") {
+        result = event.data;
+      }
+    }
+    return result;
+  }
 }
 var structuredGeneration = (input, config) => {
   return new StructuredGenerationTask(config).run(input);
@@ -5623,7 +6114,7 @@ Workflow35.prototype.textChunker = CreateWorkflow35(TextChunkerTask);
 
 // src/task/TextFillMaskTask.ts
 import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
-var modelSchema22 = TypeModel("model:TextFillMaskTask");
+var modelSchema23 = TypeModel("model:TextFillMaskTask");
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
@@ -5632,7 +6123,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     },
-    model: modelSchema22
+    model: modelSchema23
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5697,11 +6188,11 @@ var generatedTextSchema2 = {
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema23 = TypeModel("model:TextGenerationTask");
+var modelSchema24 = TypeModel("model:TextGenerationTask");
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema23,
+    model: modelSchema24,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5779,7 +6270,7 @@ Workflow37.prototype.textGeneration = CreateWorkflow37(TextGenerationTask);
 
 // src/task/TextLanguageDetectionTask.ts
 import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
-var modelSchema24 = TypeModel("model:TextLanguageDetectionTask");
+var modelSchema25 = TypeModel("model:TextLanguageDetectionTask");
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
@@ -5796,7 +6287,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema24
+    model: modelSchema25
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5866,13 +6357,13 @@ var textSchema = {
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema25 = TypeModel("model:TextQuestionAnswerTask");
+var modelSchema26 = TypeModel("model:TextQuestionAnswerTask");
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: contextSchema,
     question: questionSchema,
-    model: modelSchema25
+    model: modelSchema26
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -5905,7 +6396,7 @@ Workflow39.prototype.textQuestionAnswer = CreateWorkflow39(TextQuestionAnswerTas
 
 // src/task/TextRewriterTask.ts
 import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
-var modelSchema26 = TypeModel("model:TextRewriterTask");
+var modelSchema27 = TypeModel("model:TextRewriterTask");
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
@@ -5919,7 +6410,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     },
-    model: modelSchema26
+    model: modelSchema27
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -5957,7 +6448,7 @@ Workflow40.prototype.textRewriter = CreateWorkflow40(TextRewriterTask);
 
 // src/task/TextTranslationTask.ts
 import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
-var modelSchema27 = TypeModel("model:TextTranslationTask");
+var modelSchema28 = TypeModel("model:TextTranslationTask");
 var translationTextSchema = {
   type: "string",
   title: "Text",
@@ -5984,7 +6475,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     }),
-    model: modelSchema27
+    model: modelSchema28
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -6106,11 +6597,11 @@ var ToolCallSchema = {
   required: ["id", "name", "input"],
   additionalProperties: false
 };
-var modelSchema28 = TypeModel("model:ToolCallingTask");
+var modelSchema29 = TypeModel("model:ToolCallingTask");
 var ToolCallingInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema28,
+    model: modelSchema29,
     prompt: {
       oneOf: [
         { type: "string", title: "Prompt", description: "The prompt to send to the model" },
@@ -6145,15 +6636,7 @@ var ToolCallingInputSchema = {
       type: "array",
       title: "Messages",
       description: "Full conversation history for multi-turn interactions. When provided, used instead of prompt to construct the messages array sent to the provider.",
-      items: {
-        type: "object",
-        properties: {
-          role: { type: "string", enum: ["user", "assistant", "tool"] },
-          content: {}
-        },
-        required: ["role", "content"],
-        additionalProperties: true
-      }
+      items: ChatMessageSchema
     },
     tools: {
       type: "array",
@@ -6549,11 +7032,11 @@ Workflow43.prototype.topicSegmenter = CreateWorkflow43(TopicSegmenterTask);
 
 // src/task/UnloadModelTask.ts
 import { CreateWorkflow as CreateWorkflow44, Workflow as Workflow44 } from "@workglow/task-graph";
-var modelSchema29 = TypeModel("model");
+var modelSchema30 = TypeModel("model");
 var UnloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema29
+    model: modelSchema30
   },
   required: ["model"],
   additionalProperties: false
@@ -6561,7 +7044,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema29
+    model: modelSchema30
   },
   required: ["model"],
   additionalProperties: false
@@ -6876,7 +7359,6 @@ var similarity = (input, config) => {
   return new VectorSimilarityTask(config).run(input);
 };
 Workflow46.prototype.similarity = CreateWorkflow46(VectorSimilarityTask);
-
 // src/task/MessageConversion.ts
 function getInputMessages(input) {
   const messages = input.messages;
@@ -6925,66 +7407,46 @@ function toOpenAIMessages(input) {
   }
   for (const msg of inputMessages) {
     if (msg.role === "user") {
-      if (typeof msg.content === "string") {
-        messages.push({ role: "user", content: msg.content });
-      } else if (Array.isArray(msg.content) && msg.content.length > 0 && typeof msg.content[0]?.type === "string") {
-        const parts = [];
-        for (const block of msg.content) {
-          const b = block;
-          if (b.type === "text") {
-            parts.push({ type: "text", text: b.text });
-          } else if (b.type === "image") {
-            parts.push({
-              type: "image_url",
-              image_url: { url: `data:${b.mimeType};base64,${b.data}` }
-            });
-          } else if (b.type === "audio") {
-            const format = b.mimeType.replace(/^audio\//, "");
-            parts.push({
-              type: "input_audio",
-              input_audio: { data: b.data, format }
-            });
-          }
-        }
-        messages.push({ role: "user", content: parts });
-      } else {
-        try {
-          messages.push({ role: "user", content: JSON.stringify(msg.content) });
-        } catch {
-          messages.push({ role: "user", content: String(msg.content) });
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ type: "text", text: block.text });
+        } else if (block.type === "image") {
+          parts.push({
+            type: "image_url",
+            image_url: { url: `data:${block.mimeType};base64,${block.data}` }
+          });
         }
       }
+      messages.push({ role: "user", content: parts });
     } else if (msg.role === "assistant") {
-      if (typeof msg.content === "string") {
-        messages.push({ role: "assistant", content: msg.content.length > 0 ? msg.content : null });
-      } else if (Array.isArray(msg.content)) {
-        const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-        const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => ({
-          id: b.id,
-          type: "function",
-          function: {
-            name: b.name,
-            arguments: JSON.stringify(b.input)
-          }
-        }));
-        const entry = {
-          role: "assistant",
-          content: textParts.length > 0 ? textParts : null
-        };
-        if (toolCalls.length > 0) {
-          entry.tool_calls = toolCalls;
+      const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => ({
+        id: b.id,
+        type: "function",
+        function: {
+          name: b.name,
+          arguments: JSON.stringify(b.input)
         }
-        messages.push(entry);
+      }));
+      const entry = {
+        role: "assistant",
+        content: textParts.length > 0 ? textParts : null
+      };
+      if (toolCalls.length > 0) {
+        entry.tool_calls = toolCalls;
       }
-    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
+      messages.push(entry);
+    } else if (msg.role === "tool") {
       for (const block of msg.content) {
-        const b = block;
+        if (block.type !== "tool_result")
+          continue;
         let content;
-        if (typeof b.content === "string") {
-          content = b.content;
-        } else if (Array.isArray(b.content)) {
+        if (block.content.length === 1 && block.content[0].type === "text") {
+          content = block.content[0].text;
+        } else {
           const parts = [];
-          for (const inner of b.content) {
+          for (const inner of block.content) {
             if (inner.type === "text") {
               parts.push({ type: "text", text: inner.text });
             } else if (inner.type === "image") {
@@ -6995,14 +7457,8 @@ function toOpenAIMessages(input) {
             }
           }
           content = parts;
-        } else {
-          content = "";
         }
-        messages.push({
-          role: "tool",
-          content,
-          tool_call_id: b.tool_use_id
-        });
+        messages.push({ role: "tool", content, tool_call_id: block.tool_use_id });
       }
     }
   }
@@ -7032,41 +7488,18 @@ function toTextFlatMessages(input) {
   }
   for (const msg of inputMessages) {
     if (msg.role === "user") {
-      let content = "";
-      if (typeof msg.content === "string") {
-        content = msg.content;
-      } else if (Array.isArray(msg.content) && msg.content.length > 0 && typeof msg.content[0]?.type === "string") {
-        content = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-      } else if (msg.content != null) {
-        try {
-          content = JSON.stringify(msg.content);
-        } catch {
-          content = String(msg.content);
-        }
-      }
+      const content = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
       messages.push({ role: "user", content });
     } else if (msg.role === "assistant") {
-      if (typeof msg.content === "string") {
-        if (msg.content) {
-          messages.push({ role: "assistant", content: msg.content });
-        }
-      } else if (Array.isArray(msg.content)) {
-        const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-        if (text) {
-          messages.push({ role: "assistant", content: text });
-        }
+      const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      if (text) {
+        messages.push({ role: "assistant", content: text });
       }
-    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
+    } else if (msg.role === "tool") {
       for (const block of msg.content) {
-        const b = block;
-        let content;
-        if (typeof b.content === "string") {
-          content = b.content;
-        } else if (Array.isArray(b.content)) {
-          content = b.content.filter((inner) => inner.type === "text").map((inner) => inner.text).join("");
-        } else {
-          content = "";
-        }
+        if (block.type !== "tool_result")
+          continue;
+        const content = block.content.filter((inner) => inner.type === "text").map((inner) => inner.text).join("");
         messages.push({ role: "tool", content });
       }
     }
@@ -7077,6 +7510,7 @@ function toTextFlatMessages(input) {
 // src/task/index.ts
 var registerAiTasks = () => {
   const tasks = [
+    AiChatTask,
     BackgroundRemovalTask,
     ChunkToVectorTask,
     CountTokensTask,
@@ -7140,6 +7574,7 @@ export {
   textRewriter,
   textQuestionAnswer,
   textNamedEntityRecognition,
+  textMessage,
   textLanguageDetection,
   textGeneration,
   textFillMask,
@@ -7161,6 +7596,8 @@ export {
   modelSearch,
   modelInfo,
   kbToDocuments,
+  isContentBlock,
+  isChatMessage,
   isAllowedToolName,
   imageToText,
   imageSegmentation,
@@ -7234,6 +7671,7 @@ export {
   TextClassificationOutputSchema,
   TextClassificationInputSchema,
   TextChunkerTask,
+  StructuredOutputValidationError,
   StructuredGenerationTask,
   StructuredGenerationOutputSchema,
   StructuredGenerationInputSchema,
@@ -7297,19 +7735,24 @@ export {
   CountTokensInputSchema,
   ContextFormat,
   ContextBuilderTask,
+  ContentBlockSchema,
   ChunkingStrategy,
   ChunkVectorUpsertTask,
   ChunkVectorSearchTask,
   ChunkVectorHybridSearchTask,
   ChunkToVectorTask,
   ChunkRetrievalTask,
+  ChatMessageSchema,
   BackgroundRemovalTask,
   BackgroundRemovalOutputSchema,
   BackgroundRemovalInputSchema,
   AiTask,
   AiProviderRegistry,
   AiProvider,
-  AiJob
+  AiJob,
+  AiChatTask,
+  AiChatOutputSchema,
+  AiChatInputSchema
 };
 
-//# debugId=F0E9DA50FF60D85564756E2164756E21
+//# debugId=4A4F2C3AAA2FA8C064756E2164756E21