@sogni-ai/sogni-client 4.2.0-alpha.21 → 4.2.0-alpha.23

package/src/Chat/index.ts

@@ -14,61 +14,154 @@ import {
   ChatJobStateEvent,
   ChatRequestMessage,
   ChatMessage,
+  ChatRunEvent,
+  ChatRunRecord,
   HostedChatCompletionParams,
   HostedChatCompletionResult,
   LLMCostEstimation,
   LLMEstimateResponse,
   LLMModelInfo,
+  StartChatRunParams,
+  StreamChatRunEventsOptions,
   ToolCall,
   ToolHistoryEntry
 } from './types';
 import getUUID from '../lib/getUUID';
 import type ProjectsApi from '../Projects';
-import { parseInlineMediaDataUri } from '../lib/mediaValidation';
+import { mediaInputToInlineDataUri } from '../lib/mediaValidation';
 
 const MAX_VISION_IMAGE_COUNT = 20;
 const MAX_VISION_IMAGE_BYTES = 10 * 1024 * 1024;
 const MAX_VISION_IMAGE_LONGEST_SIDE = 1024;
-
-function normalizeVisionImageDataUri(input: string): string {
-  parseInlineMediaDataUri(input, 'image', {
+const EXTERNAL_CHAT_RUN_MEDIA_URL = /^https?:\/\//i;
+const INLINE_CHAT_RUN_MEDIA_URL = /^data:/i;
+const CHAT_RUN_MEDIA_CONTEXT_FIELDS = [
+  'images',
+  'videos',
+  'audio',
+  'uploadedImages',
+  'uploadedVideos',
+  'uploadedAudio'
+] as const;
+
+async function normalizeVisionImageDataUri(input: string): Promise<string> {
+  return mediaInputToInlineDataUri(input, 'image', {
     maxBytes: MAX_VISION_IMAGE_BYTES,
     maxImageLongestSide: MAX_VISION_IMAGE_LONGEST_SIDE
   });
-  return input.trim();
 }
 
-function normalizeVisionMessages(messages: ChatMessage[]): ChatMessage[] {
+async function normalizeVisionMessages(messages: ChatMessage[]): Promise<ChatMessage[]> {
   let imageCount = 0;
-  return messages.map((msg) => {
-    if (!Array.isArray(msg.content)) {
-      return msg;
-    }
+  return Promise.all(
+    messages.map(async (msg) => {
+      if (!Array.isArray(msg.content)) {
+        return msg;
+      }
 
-    return {
-      ...msg,
-      content: msg.content.map((part) => {
-        if (part.type !== 'image_url') {
-          return part;
-        }
+      return {
+        ...msg,
+        content: await Promise.all(
+          msg.content.map(async (part) => {
+            if (part.type !== 'image_url') {
+              return part;
+            }
+
+            imageCount += 1;
+            if (imageCount > MAX_VISION_IMAGE_COUNT) {
+              throw new Error(
+                `A maximum of ${MAX_VISION_IMAGE_COUNT} vision images is allowed per request`
+              );
+            }
 
-        imageCount += 1;
-        if (imageCount > MAX_VISION_IMAGE_COUNT) {
-          throw new Error(
-            `A maximum of ${MAX_VISION_IMAGE_COUNT} vision images is allowed per request`
-          );
-        }
+            return {
+              type: 'image_url' as const,
+              image_url: {
+                url: await normalizeVisionImageDataUri(part.image_url.url),
+                ...(part.image_url.detail && { detail: part.image_url.detail })
+              }
+            };
+          })
+        )
+      };
+    })
+  );
+}
 
-        return {
-          type: 'image_url' as const,
-          image_url: {
-            url: normalizeVisionImageDataUri(part.image_url.url),
-            ...(part.image_url.detail && { detail: part.image_url.detail })
-          }
-        };
-      })
-    };
+function chatRunMediaUrlViolation(path: string, value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (INLINE_CHAT_RUN_MEDIA_URL.test(trimmed)) return path;
+  if (!EXTERNAL_CHAT_RUN_MEDIA_URL.test(trimmed)) return path;
+  return null;
+}
+
+function collectChatRunMessageMediaViolations(messages: unknown[]): string[] {
+  const violations: string[] = [];
+  messages.forEach((message, messageIndex) => {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) return;
+    const content = (message as { content?: unknown }).content;
+    if (!Array.isArray(content)) return;
+    content.forEach((part, partIndex) => {
+      if (!part || typeof part !== 'object' || Array.isArray(part)) return;
+      if ((part as { type?: unknown }).type !== 'image_url') return;
+      const imageUrl = (part as { image_url?: unknown }).image_url;
+      if (!imageUrl || typeof imageUrl !== 'object' || Array.isArray(imageUrl)) return;
+      const violation = chatRunMediaUrlViolation(
+        `messages[${messageIndex}].content[${partIndex}].image_url.url`,
+        (imageUrl as { url?: unknown }).url
+      );
+      if (violation) violations.push(violation);
+    });
+  });
+  return violations;
+}
+
+function collectChatRunMediaReferenceViolations(mediaReferences: unknown[] | undefined): string[] {
+  if (!Array.isArray(mediaReferences)) return [];
+  const violations: string[] = [];
+  mediaReferences.forEach((reference, index) => {
+    if (!reference || typeof reference !== 'object' || Array.isArray(reference)) return;
+    const record = reference as { url?: unknown; dataUri?: unknown; data_uri?: unknown };
+    const urlViolation = chatRunMediaUrlViolation(`mediaReferences[${index}].url`, record.url);
+    if (urlViolation) violations.push(urlViolation);
+    if (typeof record.dataUri === 'string' && record.dataUri.trim()) {
+      violations.push(`mediaReferences[${index}].dataUri`);
+    }
+    if (typeof record.data_uri === 'string' && record.data_uri.trim()) {
+      violations.push(`mediaReferences[${index}].data_uri`);
+    }
   });
+  return violations;
+}
+
+function collectChatRunMediaContextViolations(
+  mediaContext: StartChatRunParams['mediaContext'] | undefined
+): string[] {
+  if (!mediaContext) return [];
+  const violations: string[] = [];
+  for (const field of CHAT_RUN_MEDIA_CONTEXT_FIELDS) {
+    const values = mediaContext[field];
+    if (!Array.isArray(values)) continue;
+    values.forEach((value, index) => {
+      const violation = chatRunMediaUrlViolation(`mediaContext.${field}[${index}]`, value);
+      if (violation) violations.push(violation);
+    });
+  }
+  return violations;
+}
+
+function assertChatRunUsesExternalMedia(params: StartChatRunParams): void {
+  const violations = [
+    ...collectChatRunMessageMediaViolations(params.messages),
+    ...collectChatRunMediaReferenceViolations(params.mediaReferences),
+    ...collectChatRunMediaContextViolations(params.mediaContext)
+  ];
+  if (violations.length === 0) return;
+  throw new Error(
+    `Durable chat runs do not support inline base64/data URI media. Upload media first and pass HTTP(S) URLs instead. Offending field(s): ${violations.join(', ')}`
+  );
 }
 
 export interface ChatApiEvents {
@@ -136,10 +229,37 @@ class ChatApi extends ApiGroup<ChatApiEvents> {
       ((params: ChatCompletionParams) => Promise<ChatStream | ChatCompletionResult>);
   };
 
+  /**
+   * Hosted REST chat completion (`POST /v1/chat/completions`). The API
+   * executes any eligible hosted tools server-side and returns the
+   * final result within the request lifetime.
+   */
   hosted: {
     create: (params: HostedChatCompletionParams) => Promise<HostedChatCompletionResult>;
   };
 
+  /**
+   * Durable hosted chat runs (`POST /v1/chat/runs`). A run is submitted
+   * and persisted server-side; the executor drives the LLM/tool loop
+   * without requiring the client to stay connected. Clients can
+   * disconnect and reattach via SSE `Last-Event-ID` replay or fetch
+   * the final snapshot.
+   *
+   * - `create` returns the persisted run record immediately (202).
+   * - `get` reads the current run state.
+   * - `cancel` flips the run to `cancelled` and aborts in-flight work.
+   * - `streamEvents` yields `ChatRunEvent`s via SSE.
+   */
+  runs: {
+    create: (params: StartChatRunParams) => Promise<ChatRunRecord>;
+    get: (runId: string) => Promise<ChatRunRecord>;
+    cancel: (runId: string, reason?: string) => Promise<ChatRunRecord>;
+    streamEvents: (
+      runId: string,
+      options?: StreamChatRunEventsOptions
+    ) => AsyncIterableIterator<ChatRunEvent>;
+  };
+
   constructor(config: ApiConfig, projects?: ProjectsApi) {
     super(config);
 
@@ -157,6 +277,12 @@ class ChatApi extends ApiGroup<ChatApiEvents> {
     this.hosted = {
       create: this.createHostedCompletion.bind(this)
     };
+    this.runs = {
+      create: this.createChatRun.bind(this),
+      get: this.getChatRun.bind(this),
+      cancel: this.cancelChatRun.bind(this),
+      streamEvents: this.streamChatRunEvents.bind(this)
+    };
 
     // Set up the tools API (requires ProjectsApi for media generation).
     // When ProjectsApi is not provided, tool execution methods will throw at runtime.
@@ -225,7 +351,7 @@ class ChatApi extends ApiGroup<ChatApiEvents> {
     think?: boolean;
     taskProfile?: 'general' | 'coding' | 'reasoning';
   }): Promise<LLMCostEstimation> {
-    const normalizedMessages = normalizeVisionMessages(params.messages);
+    const normalizedMessages = await normalizeVisionMessages(params.messages);
     const tokenType = params.tokenType || 'sogni';
     const inputTokens = Math.ceil(
       JSON.stringify(this.stripImageDataForEstimation(normalizedMessages)).length / 4
@@ -356,7 +482,7 @@ class ChatApi extends ApiGroup<ChatApiEvents> {
       throw new Error('chat.hosted.create currently supports non-streaming requests only.');
     }
 
-    const normalizedMessages = normalizeVisionMessages(params.messages);
+    const normalizedMessages = await normalizeVisionMessages(params.messages);
     const chatTemplateKwargs =
       params.chat_template_kwargs ?? this.buildChatTemplateKwargs(params.think);
     return this.client.rest.post<HostedChatCompletionResult>(
@@ -364,7 +490,7 @@ class ChatApi extends ApiGroup<ChatApiEvents> {
       {
         model: params.model,
         messages: normalizedMessages,
-        app_source: params.app_source || params.appSource || this.client.appSource,
+        app_source: params.app_source ?? params.appSource ?? this.client.appSource,
         max_tokens: params.max_tokens,
         temperature: params.temperature,
         top_p: params.top_p,
@@ -374,12 +500,12 @@ class ChatApi extends ApiGroup<ChatApiEvents> {
         frequency_penalty: params.frequency_penalty,
         presence_penalty: params.presence_penalty,
         stop: params.stop,
-        token_type: params.token_type || params.tokenType,
+        token_type: params.token_type ?? params.tokenType,
         tools: params.tools,
         tool_choice: params.tool_choice,
         sogni_tools: this.normalizeSogniToolsMode(params.sogni_tools),
         sogni_tool_execution: params.sogni_tool_execution,
-        task_profile: params.taskProfile,
+        task_profile: params.task_profile ?? params.taskProfile,
         media_references: params.media_references ?? params.mediaReferences,
         api_media_references: params.api_media_references ?? params.apiMediaReferences,
         ...(chatTemplateKwargs && { chat_template_kwargs: chatTemplateKwargs }),
@@ -389,6 +515,165 @@ class ChatApi extends ApiGroup<ChatApiEvents> {
     );
   }
 
+  private async chatRunFetch(path: string, options: RequestInit = {}): Promise<Response> {
+    const url = new URL(path, this.client.rest.baseUrl).toString();
+    const authenticated = await this.client.auth.authenticateRequest(options);
+    return fetch(url, authenticated);
+  }
+
+  private async chatRunJson<T>(path: string, options: RequestInit = {}): Promise<T> {
+    const response = await this.chatRunFetch(path, options);
+    if (!response.ok) {
+      const text = await response.text();
+      let payload: Record<string, unknown> | undefined;
+      try {
+        payload = text ? (JSON.parse(text) as Record<string, unknown>) : undefined;
+      } catch {
+        payload = { message: text };
+      }
+      const message =
+        (payload && typeof payload.message === 'string' && payload.message) ||
+        response.statusText ||
+        `Chat run request failed with status ${response.status}`;
+      const err = new Error(message);
+      (err as { status?: number }).status = response.status;
+      throw err;
+    }
+    return (await response.json()) as T;
+  }
+
+  /**
+   * Submit a durable hosted chat run. Returns the persisted run record;
+   * the executor drives the LLM/tool loop server-side.
+   */
+  private async createChatRun(params: StartChatRunParams): Promise<ChatRunRecord> {
+    assertChatRunUsesExternalMedia(params);
+    const body: Record<string, unknown> = {
+      messages: params.messages,
+      ...(params.tools ? { tools: params.tools } : {}),
+      ...(params.toolChoice !== undefined ? { tool_choice: params.toolChoice } : {}),
+      ...(params.model ? { model: params.model } : {}),
+      ...(params.sampling ? { sampling: params.sampling } : {}),
+      ...(params.mediaReferences ? { media_references: params.mediaReferences } : {}),
+      ...(params.mediaContext ? { media_context: params.mediaContext } : {}),
+      ...(params.maxEstimatedCapacityUnits !== undefined
+        ? { max_estimated_capacity_units: params.maxEstimatedCapacityUnits }
+        : {}),
+      ...(params.confirmCost !== undefined ? { confirm_cost: params.confirmCost } : {}),
+      ...(params.sessionId ? { session_id: params.sessionId } : {}),
+      ...(params.clientMessageId ? { client_message_id: params.clientMessageId } : {}),
+      ...(params.tokenType ? { token_type: params.tokenType } : {}),
+      ...(params.appSource ? { app_source: params.appSource } : {})
+    };
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+    if (params.idempotencyKey) headers['Idempotency-Key'] = params.idempotencyKey;
+    const response = await this.chatRunJson<{
+      status: string;
+      data: { run: ChatRunRecord; idempotent?: boolean };
+    }>('/v1/chat/runs', {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body)
+    });
+    return response.data.run;
+  }
+
+  /** Read a persisted chat run record. */
+  private async getChatRun(runId: string): Promise<ChatRunRecord> {
+    const response = await this.chatRunJson<{ status: string; data: { run: ChatRunRecord } }>(
+      `/v1/chat/runs/${encodeURIComponent(runId)}`
+    );
+    return response.data.run;
+  }
+
+  /** Cancel an in-flight chat run. */
+  private async cancelChatRun(runId: string, reason?: string): Promise<ChatRunRecord> {
+    const response = await this.chatRunJson<{ status: string; data: { run: ChatRunRecord } }>(
+      `/v1/chat/runs/${encodeURIComponent(runId)}/cancel`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(reason ? { reason } : {})
+      }
+    );
+    return response.data.run;
+  }
+
+  /**
+   * SSE iterator over chat-run events. Honors `Last-Event-ID` for replay.
+   * Yields events as `ChatRunEvent`. Caller is responsible for breaking
+   * the loop when they see a terminal `run_*` event type they care about.
+   */
+  private async *streamChatRunEvents(
+    runId: string,
+    options: StreamChatRunEventsOptions = {}
+  ): AsyncIterableIterator<ChatRunEvent> {
+    const headers: Record<string, string> = { Accept: 'text/event-stream' };
+    if (options.lastEventId !== undefined && Number.isFinite(options.lastEventId)) {
+      headers['Last-Event-ID'] = String(options.lastEventId);
+    }
+    const response = await this.chatRunFetch(
+      `/v1/chat/runs/${encodeURIComponent(runId)}/events/stream`,
+      { headers, signal: options.signal }
+    );
+    if (!response.ok || !response.body) {
+      throw new Error(`Chat run event stream failed with status ${response.status}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    const findFrameBoundary = (source: string): { index: number; length: number } | null => {
+      const lf = source.indexOf('\n\n');
+      const crlf = source.indexOf('\r\n\r\n');
+      if (lf === -1 && crlf === -1) return null;
+      if (lf === -1) return { index: crlf, length: 4 };
+      if (crlf === -1 || lf < crlf) return { index: lf, length: 2 };
+      return { index: crlf, length: 4 };
+    };
+
+    const yieldFrame = (frame: string): ChatRunEvent | null => {
+      if (!frame.trim() || frame.startsWith(':')) return null;
+      let eventName = 'message';
+      let data = '';
+      for (const rawLine of frame.split(/\r?\n/)) {
+        if (rawLine.startsWith('event:')) eventName = rawLine.slice(6).trim();
+        else if (rawLine.startsWith('data:')) data += (data ? '\n' : '') + rawLine.slice(5).trim();
+      }
+      if (eventName === 'run_status' || !data) return null;
+      try {
+        return JSON.parse(data) as ChatRunEvent;
+      } catch {
+        return null;
+      }
+    };
+
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+          const remaining = buffer.trim();
+          if (remaining) {
+            const parsed = yieldFrame(remaining);
+            if (parsed) yield parsed;
+          }
+          return;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        let boundary = findFrameBoundary(buffer);
+        while (boundary !== null) {
+          const frame = buffer.slice(0, boundary.index);
+          buffer = buffer.slice(boundary.index + boundary.length);
+          boundary = findFrameBoundary(buffer);
+          const parsed = yieldFrame(frame);
+          if (parsed) yield parsed;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
   /**
    * Send a single chat completion request (no auto tool execution).
    */
@@ -396,7 +681,7 @@ class ChatApi extends ApiGroup<ChatApiEvents> {
     params: ChatCompletionParams
   ): Promise<ChatStream | ChatCompletionResult> {
     const jobID = getUUID();
-    const normalizedMessages = normalizeVisionMessages(params.messages);
+    const normalizedMessages = await normalizeVisionMessages(params.messages);
 
     // Build chat_template_kwargs from think parameter
     const chatTemplateKwargs = this.buildChatTemplateKwargs(params.think);

package/src/Chat/modelRouting.ts

@@ -3,11 +3,28 @@ import { getVideoWorkflowType } from '../Projects/utils';
 export { getVideoWorkflowType };
 
 /**
- * Public SDK-local copy of the pure model routing helpers from
- * @sogni/creative-agent/backbone/reference. Keep this file self-contained so
- * published SDK consumers do not need the private creative-agent package.
+ * Public SDK-local routing helpers. The validator surface is generated from
+ * @sogni/creative-agent/src/backbone/reference/toolValidation.ts via
+ * `npm run sync:hosted-tool-validation` and re-exported below so SDK
+ * consumers do not need the private creative-agent package while still
+ * inheriting the full validator (pattern auto-anchoring, bounds, oneOf/anyOf,
+ * nested recursion, coercion, stripping).
  */
 
+export type {
+  HostedToolSchemaProperty,
+  HostedToolSchema,
+  HostedToolDefinition,
+  ValidateHostedToolArgumentsOptions,
+  HostedToolArgumentValidationResult,
+  NormalizeHostedToolArgumentsResult
+} from './hostedToolValidation.generated';
+export {
+  validateAndNormalizeHostedToolArguments,
+  validateHostedToolArguments,
+  assertHostedToolArguments
+} from './hostedToolValidation.generated';
+
 export type BackboneMediaType = 'image' | 'video' | 'audio';
 
 export type VideoWorkflow =
@@ -49,28 +66,6 @@ export interface SelectedBackboneModel {
   selectedBy: 'requestedModel' | 'preferredModel' | 'workerCount';
 }
 
-export interface HostedToolSchemaProperty {
-  type?: string | string[];
-  enum?: unknown[];
-  items?: HostedToolSchemaProperty;
-}
-
-export interface HostedToolSchema {
-  required?: string[];
-  properties?: Record<string, HostedToolSchemaProperty>;
-}
-
-export interface HostedToolDefinition {
-  function: {
-    name: string;
-    parameters?: HostedToolSchema;
-  };
-}
-
-export interface ValidateHostedToolArgumentsOptions {
-  skipEnumProperties?: string[];
-}
-
 export const PREFERRED_MODEL_IDS = {
   image: {
     gptImage2: 'gpt-image-2',
@@ -269,25 +264,25 @@ export function resolveHostedToolModelSelector(
 
   let selectors: Record<string, string> | null = null;
   switch (toolName) {
-    case 'sogni_generate_image':
+    case 'generate_image':
       selectors = IMAGE_MODEL_SELECTORS;
       break;
-    case 'sogni_edit_image':
+    case 'edit_image':
       selectors = EDIT_IMAGE_MODEL_SELECTORS;
       break;
-    case 'sogni_generate_video':
+    case 'generate_video':
       selectors =
         isNonEmptyString(args.reference_image_url) || isNonEmptyString(args.reference_image_end_url)
           ? IMAGE_VIDEO_MODEL_SELECTORS
           : TEXT_VIDEO_MODEL_SELECTORS;
       break;
-    case 'sogni_sound_to_video':
+    case 'sound_to_video':
       selectors = SOUND_TO_VIDEO_MODEL_SELECTORS;
       break;
-    case 'sogni_video_to_video':
+    case 'video_to_video':
       selectors = VIDEO_TO_VIDEO_MODEL_SELECTORS;
       break;
-    case 'sogni_generate_music':
+    case 'generate_music':
       selectors = MUSIC_MODEL_SELECTORS;
       break;
     default:
@@ -299,125 +294,6 @@ export function resolveHostedToolModelSelector(
   );
 }
 
-function matchesType(value: unknown, type: string): boolean {
-  switch (type) {
-    case 'array':
-      return Array.isArray(value);
-    case 'integer':
-      return typeof value === 'number' && Number.isInteger(value);
-    case 'number':
-      return typeof value === 'number' && Number.isFinite(value);
-    case 'boolean':
-      return typeof value === 'boolean';
-    case 'object':
-      return typeof value === 'object' && value !== null && !Array.isArray(value);
-    case 'string':
-      return typeof value === 'string';
-    case 'null':
-      return value === null;
-    default:
-      return true;
-  }
-}
-
-function typeLabel(type: string | string[] | undefined): string {
-  if (Array.isArray(type)) return type.join(' or ');
-  return type ?? 'valid value';
-}
-
-function typeList(type: string | string[] | undefined): string[] {
-  if (!type) return [];
-  return Array.isArray(type) ? type : [type];
-}
-
-function formatEnum(values: unknown[]): string {
-  return values.map((value) => JSON.stringify(value)).join(', ');
-}
-
-export function validateHostedToolArguments(
-  tools: HostedToolDefinition[],
-  toolName: string,
-  args: Record<string, unknown>,
-  options: ValidateHostedToolArgumentsOptions = {}
-): { ok: boolean; errors: string[] } {
-  if (!args || typeof args !== 'object' || Array.isArray(args)) {
-    return {
-      ok: false,
-      errors: ['Tool arguments must be a JSON object']
-    };
-  }
-
-  const tool = tools.find((candidate) => candidate.function.name === toolName);
-  if (!tool) {
-    return {
-      ok: false,
-      errors: [`Unknown hosted Sogni tool "${toolName}"`]
-    };
-  }
-
-  const schema = tool.function.parameters;
-  if (!schema) {
-    return { ok: true, errors: [] };
-  }
-
-  const errors: string[] = [];
-  const properties = schema.properties ?? {};
-  const skipEnumProperties = new Set(options.skipEnumProperties ?? ['model']);
-
-  for (const required of schema.required ?? []) {
-    if (args[required] === undefined || args[required] === null) {
-      errors.push(`Missing required argument "${required}"`);
-    }
-  }
-
-  for (const [name, value] of Object.entries(args)) {
-    if (value === undefined || value === null) continue;
-
-    const property = properties[name];
-    if (!property) continue;
-
-    const allowedTypes = typeList(property.type);
-    if (allowedTypes.length > 0 && !allowedTypes.some((type) => matchesType(value, type))) {
-      errors.push(`Argument "${name}" must be ${typeLabel(property.type)}`);
-      continue;
-    }
-
-    if (
-      property.enum &&
-      !skipEnumProperties.has(name) &&
-      !property.enum.some((candidate) => candidate === value)
-    ) {
-      errors.push(`Argument "${name}" must be one of ${formatEnum(property.enum)}`);
-    }
-
-    if (Array.isArray(value) && property.items?.type) {
-      const itemTypes = typeList(property.items.type);
-      value.forEach((item, index) => {
-        if (!itemTypes.some((type) => matchesType(item, type))) {
-          errors.push(`Argument "${name}[${index}]" must be ${typeLabel(property.items?.type)}`);
-        }
-      });
-    }
-  }
-
-  return {
-    ok: errors.length === 0,
-    errors
-  };
-}
-
-export function assertHostedToolArguments(
-  tools: HostedToolDefinition[],
-  toolName: string,
-  args: Record<string, unknown>,
-  options?: ValidateHostedToolArgumentsOptions
-): void {
-  const result = validateHostedToolArguments(tools, toolName, args, options);
-  if (!result.ok) {
-    throw new Error(`Invalid ${toolName} arguments: ${result.errors.join('; ')}`);
-  }
-}
-
 function isObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }