@modelrelay/sdk 5.3.0 → 8.1.0

package/dist/{chunk-5O4NJXLJ.js → chunk-HHBAD7FF.js}

@@ -220,7 +220,7 @@ async function parseErrorResponse(response, retries) {
 // package.json
 var package_default = {
   name: "@modelrelay/sdk",
-  version: "4.0.0",
+  version: "5.5.0",
   description: "TypeScript SDK for the ModelRelay API",
   type: "module",
   main: "dist/index.cjs",

package/dist/{chunk-LZDGY24E.js → chunk-PKGWFDGU.js}

@@ -134,6 +134,15 @@ var PathEscapeError = class extends ModelRelayError {
     this.resolvedPath = opts.resolvedPath;
   }
 };
+var AgentMaxTurnsError = class extends ModelRelayError {
+  constructor(maxTurns) {
+    super(`agent exceeded maximum turns (${maxTurns}) without completing`, {
+      category: "config",
+      status: 400
+    });
+    this.maxTurns = maxTurns;
+  }
+};
 async function parseErrorResponse(response, retries) {
   const requestId = response.headers.get("X-ModelRelay-Request-Id") || response.headers.get("X-Request-Id") || void 0;
   const fallbackMessage = response.statusText || "Request failed";
@@ -220,7 +229,7 @@ async function parseErrorResponse(response, retries) {
 // package.json
 var package_default = {
   name: "@modelrelay/sdk",
-  version: "5.3.0",
+  version: "7.0.0",
   description: "TypeScript SDK for the ModelRelay API",
   type: "module",
   main: "dist/index.cjs",
@@ -355,15 +364,9 @@ var OutputItemTypes = {
 };
 var ToolTypes = {
   Function: "function",
-  Web: "web",
   XSearch: "x_search",
   CodeExecution: "code_execution"
 };
-var WebToolIntents = {
-  Auto: "auto",
-  SearchWeb: "search_web",
-  FetchURL: "fetch_url"
-};
 var ToolChoiceTypes = {
   Auto: "auto",
   Required: "required",
@@ -490,7 +493,10 @@ function convertZodType(schema) {
     case "ZodNullable":
       return convertZodNullable(def);
     case "ZodDefault":
-      return { ...convertZodType(def.innerType), default: def.defaultValue() };
+      return {
+        ...convertZodType(def.innerType),
+        default: def.defaultValue()
+      };
     case "ZodEffects":
       return convertZodType(def.schema);
     case "ZodRecord":
@@ -685,9 +691,14 @@ function convertZodTuple(def) {
   }
   return result;
 }
-function createFunctionToolFromSchema(name, description, schema, options) {
-  const jsonSchema = zodToJsonSchema(schema, options);
-  return createFunctionTool(name, description, jsonSchema);
+function createTypedTool(def) {
+  const jsonSchema = zodToJsonSchema(def.parameters, def.options);
+  const tool = createFunctionTool(def.name, def.description, jsonSchema);
+  Object.defineProperty(tool, "_schema", {
+    value: def.parameters,
+    enumerable: false
+  });
+  return tool;
 }
 function createFunctionTool(name, description, parameters) {
   const fn = { name, description };
@@ -699,17 +710,6 @@ function createFunctionTool(name, description, parameters) {
     function: fn
   };
 }
-function createWebTool(options) {
-  return {
-    type: ToolTypes.Web,
-    web: options ? {
-      intent: options.intent,
-      allowedDomains: options.allowedDomains,
-      excludedDomains: options.excludedDomains,
-      maxUses: options.maxUses
-    } : void 0
-  };
-}
 function toolChoiceAuto() {
   return { type: ToolChoiceTypes.Auto };
 }
@@ -824,7 +824,7 @@ var ToolArgsError = class extends Error {
     this.rawArguments = rawArguments;
   }
 };
-function parseToolArgs(call, schema) {
+function parseToolArgsWithSchema(call, schema) {
   const toolName = call.function?.name ?? "unknown";
   const rawArgs = call.function?.arguments ?? "";
   let parsed;
@@ -865,41 +865,89 @@ function parseToolArgs(call, schema) {
     );
   }
 }
-function tryParseToolArgs(call, schema) {
-  try {
-    const data = parseToolArgs(call, schema);
-    return { success: true, data };
-  } catch (err) {
-    if (err instanceof ToolArgsError) {
-      return { success: false, error: err };
-    }
-    const toolName = call.function?.name ?? "unknown";
-    const rawArgs = call.function?.arguments ?? "";
-    return {
-      success: false,
-      error: new ToolArgsError(
-        err instanceof Error ? err.message : String(err),
-        call.id,
-        toolName,
-        rawArgs
-      )
-    };
+function parseTypedToolCall(call, tool) {
+  if (!call.function) {
+    throw new ToolArgsError(
+      "Tool call missing function",
+      call.id,
+      tool.function.name,
+      ""
+    );
   }
-}
-function parseToolArgsRaw(call) {
-  const toolName = call.function?.name ?? "unknown";
-  const rawArgs = call.function?.arguments ?? "";
-  try {
-    return rawArgs ? JSON.parse(rawArgs) : {};
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Invalid JSON in arguments";
+  if (call.function.name !== tool.function.name) {
     throw new ToolArgsError(
-      `Failed to parse arguments for tool '${toolName}': ${message}`,
+      `Expected tool '${tool.function.name}', got '${call.function.name}'`,
       call.id,
-      toolName,
-      rawArgs
+      tool.function.name,
+      call.function.arguments ?? ""
     );
   }
+  const parsed = parseToolArgsWithSchema(call, tool._schema);
+  return {
+    ...call,
+    function: {
+      ...call.function,
+      arguments: parsed
+    }
+  };
+}
+function getTypedToolCall(response, tool) {
+  for (const item of response.output || []) {
+    for (const call of item?.toolCalls || []) {
+      if (call.function?.name === tool.function.name) {
+        return parseTypedToolCall(call, tool);
+      }
+    }
+  }
+  return void 0;
+}
+function getTypedToolCalls(response, tool) {
+  const result = [];
+  for (const item of response.output || []) {
+    for (const call of item?.toolCalls || []) {
+      if (call.function?.name === tool.function.name) {
+        result.push(parseTypedToolCall(call, tool));
+      }
+    }
+  }
+  return result;
+}
+function getToolName(call) {
+  return call.function?.name ?? "";
+}
+function getToolArgsRaw(call) {
+  return call.function?.arguments ?? "";
+}
+function getToolArgs(call) {
+  const raw = call.function?.arguments ?? "";
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function getAllToolCalls(response) {
+  const calls = [];
+  for (const item of response.output || []) {
+    if (item.toolCalls) {
+      calls.push(...item.toolCalls);
+    }
+  }
+  return calls;
+}
+function getAssistantText(response) {
+  const texts = [];
+  for (const item of response.output || []) {
+    if (item.role === "assistant" && item.content) {
+      for (const part of item.content) {
+        if (part.type === "text" && part.text) {
+          texts.push(part.text);
+        }
+      }
+    }
+  }
+  return texts.join("");
 }
 var ToolRegistry = class {
   constructor() {
@@ -1075,6 +1123,7 @@ export {
   WorkflowValidationError,
   ToolArgumentError,
   PathEscapeError,
+  AgentMaxTurnsError,
   parseErrorResponse,
   SDK_VERSION,
   DEFAULT_BASE_URL,
@@ -1093,7 +1142,6 @@ export {
   InputItemTypes,
   OutputItemTypes,
   ToolTypes,
-  WebToolIntents,
   ToolChoiceTypes,
   OutputFormatTypes,
   mergeMetrics,
@@ -1108,9 +1156,8 @@ export {
   createToolCall,
   createFunctionCall,
   zodToJsonSchema,
-  createFunctionToolFromSchema,
+  createTypedTool,
   createFunctionTool,
-  createWebTool,
   toolChoiceAuto,
   toolChoiceRequired,
   toolChoiceNone,
@@ -1121,9 +1168,14 @@ export {
   assistantMessageWithToolCalls,
   ToolCallAccumulator,
   ToolArgsError,
-  parseToolArgs,
-  tryParseToolArgs,
-  parseToolArgsRaw,
+  parseTypedToolCall,
+  getTypedToolCall,
+  getTypedToolCalls,
+  getToolName,
+  getToolArgsRaw,
+  getToolArgs,
+  getAllToolCalls,
+  getAssistantText,
   ToolRegistry,
   formatToolErrorForModel,
   hasRetryableErrors,

package/dist/{chunk-HLJAMT7F.js → chunk-RVHKBQ7X.js}

@@ -220,7 +220,7 @@ async function parseErrorResponse(response, retries) {
 // package.json
 var package_default = {
   name: "@modelrelay/sdk",
-  version: "4.0.1",
+  version: "5.1.0",
   description: "TypeScript SDK for the ModelRelay API",
   type: "module",
   main: "dist/index.cjs",