modelfusion 0.110.0 → 0.112.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## v0.112.0 - 2024-01-02
+
+### Changed
+
+- **breaking change**: renamed `useToolsOrGenerateText` to `useTools`
+- **breaking change**: renamed `generateToolCallsOrText` to `generateToolCalls`
+
+### Removed
+
+- Restriction on tool names. OpenAI tool calls do not have such a restriction.
+
+## v0.111.0 - 2024-01-01
+
+Reworked API configuration support.
+
+### Added
+
+- All providers now have an `Api` function that you can call to create custom API configurations. The base URL set up is more flexible and allows you to override parts of the base URL selectively.
+- `api` namespace with retry and throttle configurations
+
+### Changed
+
+- Updated Cohere models.
+- Updated LMNT API calls to LMNT `v1` API.
+- **breaking change**: Renamed `throttleUnlimitedConcurrency` to `throttleOff`.
+
 ## v0.110.0 - 2023-12-30
 
 ### Changed

package/README.md

@@ -328,67 +328,7 @@ Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai),
 
 Tools are functions that can be executed by an AI model. They are useful for building chatbots and agents.
 
-Predefined tools: [Math.js](https://modelfusion.dev/guide/tools/predefined-tools/mathjs), [SerpAPI](https://modelfusion.dev/guide/tools/predefined-tools/serpapi), [Google Custom Search](https://modelfusion.dev/guide/tools/predefined-tools/google-custom-search)
-
-#### [Creating Tools](https://modelfusion.dev/guide/tools/create-tools)
-
-A tool is comprised of an async execute function, a name, a description, and a schema for the input parameters.
-
-```ts
-const calculator = new Tool({
-  name: "calculator",
-  description: "Execute a calculation",
-
-  parameters: zodSchema(
-    z.object({
-      a: z.number().describe("The first number."),
-      b: z.number().describe("The second number."),
-      operator: z
-        .enum(["+", "-", "*", "/"])
-        .describe("The operator (+, -, *, /)."),
-    })
-  ),
-
-  execute: async ({ a, b, operator }) => {
-    switch (operator) {
-      case "+":
-        return a + b;
-      case "-":
-        return a - b;
-      case "*":
-        return a * b;
-      case "/":
-        return a / b;
-      default:
-        throw new Error(`Unknown operator: ${operator}`);
-    }
-  },
-});
-```
-
-#### [generateToolCall](https://modelfusion.dev/guide/tools/generate-tool-call)
-
-With `generateToolCall`, you can generate a tool call for a specific tool with a language model that supports tools calls (e.g. OpenAI Chat). This function does not execute the tools.
-
-```ts
-const { id, name, args } = await generateToolCall(
-  openai.ChatTextGenerator({ model: "gpt-3.5-turbo" }),
-  calculator,
-  [openai.ChatMessage.user("What's fourteen times twelve?")]
-);
-```
-
-#### [generateToolCallsOrText](https://modelfusion.dev/guide/tools/generate-tool-calls-or-text)
-
-With `generateToolCallsOrText`, you can ask a language model to generate several tool calls as well as text. The model will choose which tools (if any) should be called with which arguments. Both the text and the tool calls are optional. This function does not execute the tools.
-
-```ts
-const { text, toolCalls } = await generateToolCallsOrText(
-  openai.ChatTextGenerator({ model: "gpt-3.5-turbo" }),
-  [toolA, toolB, toolC],
-  [openai.ChatMessage.user(query)]
-);
-```
+Predefined tools: [Math.js](https://modelfusion.dev/guide/tools/predefined-tools/mathjs), [MediaWiki Search](https://modelfusion.dev/guide/tools/predefined-tools/mediawiki-search), [SerpAPI](https://modelfusion.dev/guide/tools/predefined-tools/serpapi), [Google Custom Search](https://modelfusion.dev/guide/tools/predefined-tools/google-custom-search)
 
 #### [executeTool](https://modelfusion.dev/guide/tools/execute-tool)
 
@@ -420,21 +360,57 @@ console.log(`Ok:`, ok);
 console.log(`Result or Error:`, result);
 ```
 
-#### [useToolsOrGenerateText](https://modelfusion.dev/guide/tools/use-tools-or-generate-text)
+#### [useTools](https://modelfusion.dev/guide/tools/use-tools-or-generate-text)
 
-With `useToolsOrGenerateText`, you can ask a language model to generate several tool calls as well as text. The model will choose which tools (if any) should be called with which arguments. Both the text and the tool calls are optional. This function executes the tools.
+With `useTools`, you can ask a language model to generate several tool calls as well as text. The model will choose which tools (if any) should be called with which arguments. Both the text and the tool calls are optional. This function executes the tools.
 
 ```ts
-const { text, toolResults } = await useToolsOrGenerateText(
+const { text, toolResults } = await useTools(
   openai.ChatTextGenerator({ model: "gpt-3.5-turbo" }),
   [calculator /* ... */],
   [openai.ChatMessage.user("What's fourteen times twelve?")]
 );
 ```
 
+#### [Creating Tools](https://modelfusion.dev/guide/tools/create-tools)
+
+A tool is comprised of an async execute function, a name, a description, and a schema for the input parameters.
+
+```ts
+const calculator = new Tool({
+  name: "calculator",
+  description: "Execute a calculation",
+
+  parameters: zodSchema(
+    z.object({
+      a: z.number().describe("The first number."),
+      b: z.number().describe("The second number."),
+      operator: z
+        .enum(["+", "-", "*", "/"])
+        .describe("The operator (+, -, *, /)."),
+    })
+  ),
+
+  execute: async ({ a, b, operator }) => {
+    switch (operator) {
+      case "+":
+        return a + b;
+      case "-":
+        return a - b;
+      case "*":
+        return a * b;
+      case "/":
+        return a / b;
+      default:
+        throw new Error(`Unknown operator: ${operator}`);
+    }
+  },
+});
+```
+
 #### [Agent Loop](https://modelfusion.dev/guide/tools/agent-loop)
 
-You can use `useToolsOrGenerateText` to implement an agent loop that responds to user messages and executes tools. [Learn more](https://modelfusion.dev/guide/tools/agent-loop).
+You can use `useTools` to implement an agent loop that responds to user messages and executes tools. [Learn more](https://modelfusion.dev/guide/tools/agent-loop).
 
 ### [Vector Indices](https://modelfusion.dev/guide/vector-index)
 

package/core/FunctionEvent.d.ts

@@ -1,11 +1,11 @@
-import { ExtensionFunctionStartedEvent, ExtensionFunctionFinishedEvent } from "./ExtensionFunctionEvent.js";
 import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
 import { RetrieveFinishedEvent, RetrieveStartedEvent } from "../retriever/RetrieveEvent.js";
 import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/execute-tool/ExecuteToolEvent.js";
 import { UseToolFinishedEvent, UseToolStartedEvent } from "../tool/use-tool/UseToolEvent.js";
-import { UseToolsOrGenerateTextFinishedEvent, UseToolsOrGenerateTextStartedEvent } from "../tool/use-tools-or-generate-text/UseToolsOrGenerateTextEvent.js";
+import { useToolsFinishedEvent, useToolsStartedEvent } from "../tool/use-tools/UseToolsEvent.js";
 import { UpsertIntoVectorIndexFinishedEvent, UpsertIntoVectorIndexStartedEvent } from "../vector-index/UpsertIntoVectorIndexEvent.js";
 import { ExecuteFunctionFinishedEvent, ExecuteFunctionStartedEvent } from "./ExecuteFunctionEvent.js";
+import { ExtensionFunctionFinishedEvent, ExtensionFunctionStartedEvent } from "./ExtensionFunctionEvent.js";
 export interface BaseFunctionEvent {
     /**
      * Unique identifier for the function call.
@@ -82,4 +82,4 @@ export interface BaseFunctionFinishedEvent extends BaseFunctionEvent {
      */
     result: BaseFunctionFinishedEventResult;
 }
-export type FunctionEvent = ExecuteFunctionStartedEvent | ExecuteFunctionFinishedEvent | ExecuteToolStartedEvent | ExecuteToolFinishedEvent | ExtensionFunctionStartedEvent | ExtensionFunctionFinishedEvent | ModelCallStartedEvent | ModelCallFinishedEvent | RetrieveStartedEvent | RetrieveFinishedEvent | UpsertIntoVectorIndexStartedEvent | UpsertIntoVectorIndexFinishedEvent | UseToolStartedEvent | UseToolFinishedEvent | UseToolsOrGenerateTextStartedEvent | UseToolsOrGenerateTextFinishedEvent;
+export type FunctionEvent = ExecuteFunctionStartedEvent | ExecuteFunctionFinishedEvent | ExecuteToolStartedEvent | ExecuteToolFinishedEvent | ExtensionFunctionStartedEvent | ExtensionFunctionFinishedEvent | ModelCallStartedEvent | ModelCallFinishedEvent | RetrieveStartedEvent | RetrieveFinishedEvent | UpsertIntoVectorIndexStartedEvent | UpsertIntoVectorIndexFinishedEvent | UseToolStartedEvent | UseToolFinishedEvent | useToolsStartedEvent | useToolsFinishedEvent;

package/core/api/ApiFacade.cjs

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./retryNever.cjs"), exports);
+__exportStar(require("./retryWithExponentialBackoff.cjs"), exports);
+__exportStar(require("./throttleMaxConcurrency.cjs"), exports);
+__exportStar(require("./throttleOff.cjs"), exports);

package/core/api/ApiFacade.d.ts

@@ -0,0 +1,4 @@
+export * from "./retryNever.js";
+export * from "./retryWithExponentialBackoff.js";
+export * from "./throttleMaxConcurrency.js";
+export * from "./throttleOff.js";

package/core/api/ApiFacade.js

@@ -0,0 +1,4 @@
+export * from "./retryNever.js";
+export * from "./retryWithExponentialBackoff.js";
+export * from "./throttleMaxConcurrency.js";
+export * from "./throttleOff.js";

package/core/api/BaseUrlApiConfiguration.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseUrlApiConfiguration = void 0;
+exports.BaseUrlApiConfigurationWithDefaults = exports.BaseUrlApiConfiguration = void 0;
 const AbstractApiConfiguration_js_1 = require("./AbstractApiConfiguration.cjs");
 /**
- * An API configuration that uses a base URL and a set of headers.
+ * An API configuration that uses different URL parts and a set of headers.
  *
  * You can use it to configure custom APIs for models, e.g. your own internal OpenAI proxy with custom headers.
  */
@@ -22,11 +22,53 @@ class BaseUrlApiConfiguration extends AbstractApiConfiguration_js_1.AbstractApiC
             writable: true,
             value: void 0
         });
-        this.baseUrl = baseUrl;
-        this.headers = headers;
+        this.baseUrl = typeof baseUrl == "string" ? parseBaseUrl(baseUrl) : baseUrl;
+        this.headers = headers ?? {};
     }
     assembleUrl(path) {
-        return `${this.baseUrl}${path}`;
+        let basePath = this.baseUrl.path;
+        // ensure base path ends without a slash
+        if (basePath.endsWith("/")) {
+            basePath = basePath.slice(0, -1);
+        }
+        // ensure path starts with a slash
+        if (!path.startsWith("/")) {
+            path = `/${path}`;
+        }
+        return `${this.baseUrl.protocol}://${this.baseUrl.host}:${this.baseUrl.port}${basePath}${path}`;
     }
 }
 exports.BaseUrlApiConfiguration = BaseUrlApiConfiguration;
+class BaseUrlApiConfigurationWithDefaults extends BaseUrlApiConfiguration {
+    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, }) {
+        super({
+            baseUrl: resolveBaseUrl(baseUrl, baseUrlDefaults),
+            headers,
+            retry,
+            throttle,
+        });
+    }
+}
+exports.BaseUrlApiConfigurationWithDefaults = BaseUrlApiConfigurationWithDefaults;
+function parseBaseUrl(baseUrl) {
+    const url = new URL(baseUrl);
+    return {
+        protocol: url.protocol.slice(0, -1), // remove trailing colon
+        host: url.hostname,
+        port: url.port,
+        path: url.pathname,
+    };
+}
+function resolveBaseUrl(baseUrl = {}, baseUrlDefaults) {
+    if (typeof baseUrl == "string") {
+        return baseUrl;
+    }
+    else {
+        return {
+            protocol: baseUrl.protocol ?? baseUrlDefaults.protocol,
+            host: baseUrl.host ?? baseUrlDefaults.host,
+            port: baseUrl.port ?? baseUrlDefaults.port,
+            path: baseUrl.path ?? baseUrlDefaults.path,
+        };
+    }
+}

package/core/api/BaseUrlApiConfiguration.d.ts

@@ -1,20 +1,37 @@
 import { AbstractApiConfiguration } from "./AbstractApiConfiguration.js";
 import { RetryFunction } from "./RetryFunction.js";
 import { ThrottleFunction } from "./ThrottleFunction.js";
-export type BaseUrlApiConfigurationOptions = {
-    baseUrl: string;
-    headers: Record<string, string>;
+export type UrlParts = {
+    protocol: string;
+    host: string;
+    port: string;
+    path: string;
+};
+export type BaseUrlPartsApiConfigurationOptions = {
+    baseUrl: string | UrlParts;
+    headers?: Record<string, string>;
     retry?: RetryFunction;
     throttle?: ThrottleFunction;
 };
 /**
- * An API configuration that uses a base URL and a set of headers.
+ * An API configuration that uses different URL parts and a set of headers.
  *
  * You can use it to configure custom APIs for models, e.g. your own internal OpenAI proxy with custom headers.
  */
 export declare class BaseUrlApiConfiguration extends AbstractApiConfiguration {
-    readonly baseUrl: string;
+    readonly baseUrl: UrlParts;
     readonly headers: Record<string, string>;
-    constructor({ baseUrl, headers, retry, throttle, }: BaseUrlApiConfigurationOptions);
+    constructor({ baseUrl, headers, retry, throttle, }: BaseUrlPartsApiConfigurationOptions);
     assembleUrl(path: string): string;
 }
+export type PartialBaseUrlPartsApiConfigurationOptions = {
+    baseUrl?: string | Partial<UrlParts>;
+    headers?: Record<string, string>;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+};
+export declare class BaseUrlApiConfigurationWithDefaults extends BaseUrlApiConfiguration {
+    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, }: {
+        baseUrlDefaults: UrlParts;
+    } & PartialBaseUrlPartsApiConfigurationOptions);
+}

package/core/api/BaseUrlApiConfiguration.js

@@ -1,6 +1,6 @@
 import { AbstractApiConfiguration } from "./AbstractApiConfiguration.js";
 /**
- * An API configuration that uses a base URL and a set of headers.
+ * An API configuration that uses different URL parts and a set of headers.
  *
  * You can use it to configure custom APIs for models, e.g. your own internal OpenAI proxy with custom headers.
  */
@@ -19,10 +19,51 @@ export class BaseUrlApiConfiguration extends AbstractApiConfiguration {
             writable: true,
             value: void 0
         });
-        this.baseUrl = baseUrl;
-        this.headers = headers;
+        this.baseUrl = typeof baseUrl == "string" ? parseBaseUrl(baseUrl) : baseUrl;
+        this.headers = headers ?? {};
     }
     assembleUrl(path) {
-        return `${this.baseUrl}${path}`;
+        let basePath = this.baseUrl.path;
+        // ensure base path ends without a slash
+        if (basePath.endsWith("/")) {
+            basePath = basePath.slice(0, -1);
+        }
+        // ensure path starts with a slash
+        if (!path.startsWith("/")) {
+            path = `/${path}`;
+        }
+        return `${this.baseUrl.protocol}://${this.baseUrl.host}:${this.baseUrl.port}${basePath}${path}`;
+    }
+}
+export class BaseUrlApiConfigurationWithDefaults extends BaseUrlApiConfiguration {
+    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, }) {
+        super({
+            baseUrl: resolveBaseUrl(baseUrl, baseUrlDefaults),
+            headers,
+            retry,
+            throttle,
+        });
+    }
+}
+function parseBaseUrl(baseUrl) {
+    const url = new URL(baseUrl);
+    return {
+        protocol: url.protocol.slice(0, -1), // remove trailing colon
+        host: url.hostname,
+        port: url.port,
+        path: url.pathname,
+    };
+}
+function resolveBaseUrl(baseUrl = {}, baseUrlDefaults) {
+    if (typeof baseUrl == "string") {
+        return baseUrl;
+    }
+    else {
+        return {
+            protocol: baseUrl.protocol ?? baseUrlDefaults.protocol,
+            host: baseUrl.host ?? baseUrlDefaults.host,
+            port: baseUrl.port ?? baseUrlDefaults.port,
+            path: baseUrl.path ?? baseUrlDefaults.path,
+        };
     }
 }

package/core/api/BaseUrlApiConfiguration.test.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseUrlApiConfiguration_js_1 = require("./BaseUrlApiConfiguration.cjs");
+describe("with text URLs", () => {
+    it("should assemble the correct url", async () => {
+        const api = new BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration({
+            baseUrl: "http://localhost:8080",
+        });
+        expect(api.assembleUrl("/test")).toBe("http://localhost:8080/test");
+    });
+});

package/core/api/BaseUrlApiConfiguration.test.js

@@ -0,0 +1,9 @@
+import { BaseUrlApiConfiguration } from "./BaseUrlApiConfiguration.js";
+describe("with text URLs", () => {
+    it("should assemble the correct url", async () => {
+        const api = new BaseUrlApiConfiguration({
+            baseUrl: "http://localhost:8080",
+        });
+        expect(api.assembleUrl("/test")).toBe("http://localhost:8080/test");
+    });
+});

package/core/api/callWithRetryAndThrottle.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callWithRetryAndThrottle = void 0;
-const retryWithExponentialBackoff_js_1 = require("./retryWithExponentialBackoff.cjs");
-const throttleUnlimitedConcurrency_js_1 = require("./throttleUnlimitedConcurrency.cjs");
-const callWithRetryAndThrottle = async ({ retry = (0, retryWithExponentialBackoff_js_1.retryWithExponentialBackoff)(), throttle = (0, throttleUnlimitedConcurrency_js_1.throttleUnlimitedConcurrency)(), call, }) => retry(async () => throttle(call));
+const retryNever_js_1 = require("./retryNever.cjs");
+const throttleOff_js_1 = require("./throttleOff.cjs");
+const callWithRetryAndThrottle = async ({ retry = (0, retryNever_js_1.retryNever)(), throttle = (0, throttleOff_js_1.throttleOff)(), call, }) => retry(async () => throttle(call));
 exports.callWithRetryAndThrottle = callWithRetryAndThrottle;

package/core/api/callWithRetryAndThrottle.js

@@ -1,3 +1,3 @@
-import { retryWithExponentialBackoff } from "./retryWithExponentialBackoff.js";
-import { throttleUnlimitedConcurrency } from "./throttleUnlimitedConcurrency.js";
-export const callWithRetryAndThrottle = async ({ retry = retryWithExponentialBackoff(), throttle = throttleUnlimitedConcurrency(), call, }) => retry(async () => throttle(call));
+import { retryNever } from "./retryNever.js";
+import { throttleOff } from "./throttleOff.js";
+export const callWithRetryAndThrottle = async ({ retry = retryNever(), throttle = throttleOff(), call, }) => retry(async () => throttle(call));

package/core/api/index.cjs

@@ -10,19 +10,32 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = void 0;
 __exportStar(require("./AbortError.cjs"), exports);
 __exportStar(require("./ApiCallError.cjs"), exports);
 __exportStar(require("./ApiConfiguration.cjs"), exports);
+exports.api = __importStar(require("./ApiFacade.cjs"));
 __exportStar(require("./BaseUrlApiConfiguration.cjs"), exports);
-__exportStar(require("./BaseUrlPartsApiConfiguration.cjs"), exports);
 __exportStar(require("./RetryError.cjs"), exports);
 __exportStar(require("./RetryFunction.cjs"), exports);
 __exportStar(require("./ThrottleFunction.cjs"), exports);
 __exportStar(require("./retryNever.cjs"), exports);
 __exportStar(require("./retryWithExponentialBackoff.cjs"), exports);
 __exportStar(require("./throttleMaxConcurrency.cjs"), exports);
-__exportStar(require("./throttleUnlimitedConcurrency.cjs"), exports);
+__exportStar(require("./throttleOff.cjs"), exports);

package/core/api/index.d.ts

@@ -1,12 +1,12 @@
 export * from "./AbortError.js";
 export * from "./ApiCallError.js";
 export * from "./ApiConfiguration.js";
+export * as api from "./ApiFacade.js";
 export * from "./BaseUrlApiConfiguration.js";
-export * from "./BaseUrlPartsApiConfiguration.js";
 export * from "./RetryError.js";
 export * from "./RetryFunction.js";
 export * from "./ThrottleFunction.js";
 export * from "./retryNever.js";
 export * from "./retryWithExponentialBackoff.js";
 export * from "./throttleMaxConcurrency.js";
-export * from "./throttleUnlimitedConcurrency.js";
+export * from "./throttleOff.js";

package/core/api/index.js

@@ -1,12 +1,12 @@
 export * from "./AbortError.js";
 export * from "./ApiCallError.js";
 export * from "./ApiConfiguration.js";
+export * as api from "./ApiFacade.js";
 export * from "./BaseUrlApiConfiguration.js";
-export * from "./BaseUrlPartsApiConfiguration.js";
 export * from "./RetryError.js";
 export * from "./RetryFunction.js";
 export * from "./ThrottleFunction.js";
 export * from "./retryNever.js";
 export * from "./retryWithExponentialBackoff.js";
 export * from "./throttleMaxConcurrency.js";
-export * from "./throttleUnlimitedConcurrency.js";
+export * from "./throttleOff.js";

package/core/api/postToApi.cjs

@@ -1,11 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.postToApi = exports.postJsonToApi = exports.createAudioMpegResponseHandler = exports.createTextResponseHandler = exports.createJsonResponseHandler = exports.createJsonErrorResponseHandler = void 0;
-const ZodSchema_js_1 = require("../schema/ZodSchema.cjs");
+exports.postToApi = exports.postJsonToApi = exports.createAudioMpegResponseHandler = exports.createTextResponseHandler = exports.createJsonResponseHandler = exports.createTextErrorResponseHandler = exports.createJsonErrorResponseHandler = void 0;
 const parseJSON_js_1 = require("../schema/parseJSON.cjs");
 const ApiCallError_js_1 = require("./ApiCallError.cjs");
 const createJsonErrorResponseHandler = ({ errorSchema, errorToMessage, isRetryable, }) => async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
+    // Some providers return an empty response body for some errors:
+    if (responseBody.trim() === "") {
+        return new ApiCallError_js_1.ApiCallError({
+            message: response.statusText,
+            url,
+            requestBodyValues,
+            statusCode: response.status,
+            responseBody,
+            isRetryable: isRetryable?.(response),
+        });
+    }
     // resilient parsing in case the response is not JSON or does not match the schema:
     try {
         const parsedError = (0, parseJSON_js_1.parseJSON)({
@@ -19,25 +29,38 @@ const createJsonErrorResponseHandler = ({ errorSchema, errorToMessage, isRetryab
             statusCode: response.status,
             responseBody,
             data: parsedError,
-            isRetryable: isRetryable?.(parsedError, response),
+            isRetryable: isRetryable?.(response, parsedError),
         });
     }
     catch (parseError) {
         return new ApiCallError_js_1.ApiCallError({
-            message: responseBody.trim() !== "" ? responseBody : response.statusText,
+            message: response.statusText,
             url,
             requestBodyValues,
             statusCode: response.status,
             responseBody,
+            isRetryable: isRetryable?.(response),
         });
     }
 };
 exports.createJsonErrorResponseHandler = createJsonErrorResponseHandler;
+const createTextErrorResponseHandler = ({ isRetryable, } = {}) => async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    return new ApiCallError_js_1.ApiCallError({
+        message: responseBody.trim() !== "" ? responseBody : response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseBody,
+        isRetryable: isRetryable?.(response),
+    });
+};
+exports.createTextErrorResponseHandler = createTextErrorResponseHandler;
 const createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
     const parsedResult = (0, parseJSON_js_1.safeParseJSON)({
         text: responseBody,
-        schema: new ZodSchema_js_1.ZodSchema(responseSchema),
+        schema: responseSchema,
     });
     if (!parsedResult.success) {
         throw new ApiCallError_js_1.ApiCallError({

package/core/api/postToApi.d.ts

@@ -1,7 +1,5 @@
 /// <reference types="node" />
-import { z } from "zod";
 import { Schema } from "../schema/Schema.js";
-import { ZodSchema } from "../schema/ZodSchema.js";
 import { ApiCallError } from "./ApiCallError.js";
 export type ResponseHandler<T> = (options: {
     url: string;
@@ -11,9 +9,12 @@ export type ResponseHandler<T> = (options: {
 export declare const createJsonErrorResponseHandler: <T>({ errorSchema, errorToMessage, isRetryable, }: {
     errorSchema: Schema<T>;
     errorToMessage: (error: T) => string;
-    isRetryable?: ((error: T, response: Response) => boolean) | undefined;
+    isRetryable?: ((response: Response, error?: T | undefined) => boolean) | undefined;
 }) => ResponseHandler<ApiCallError>;
-export declare const createJsonResponseHandler: <T>(responseSchema: z.ZodType<T, z.ZodTypeDef, T>) => ResponseHandler<T>;
+export declare const createTextErrorResponseHandler: ({ isRetryable, }?: {
+    isRetryable?: ((response: Response) => boolean) | undefined;
+}) => ResponseHandler<ApiCallError>;
+export declare const createJsonResponseHandler: <T>(responseSchema: Schema<T>) => ResponseHandler<T>;
 export declare const createTextResponseHandler: () => ResponseHandler<string>;
 export declare const createAudioMpegResponseHandler: () => ResponseHandler<Buffer>;
 export declare const postJsonToApi: <T>({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, }: {

package/core/api/postToApi.js

@@ -1,8 +1,18 @@
-import { ZodSchema } from "../schema/ZodSchema.js";
 import { parseJSON, safeParseJSON } from "../schema/parseJSON.js";
 import { ApiCallError } from "./ApiCallError.js";
 export const createJsonErrorResponseHandler = ({ errorSchema, errorToMessage, isRetryable, }) => async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
+    // Some providers return an empty response body for some errors:
+    if (responseBody.trim() === "") {
+        return new ApiCallError({
+            message: response.statusText,
+            url,
+            requestBodyValues,
+            statusCode: response.status,
+            responseBody,
+            isRetryable: isRetryable?.(response),
+        });
+    }
     // resilient parsing in case the response is not JSON or does not match the schema:
     try {
         const parsedError = parseJSON({
@@ -16,24 +26,36 @@ export const createJsonErrorResponseHandler = ({ errorSchema, errorToMessage, is
             statusCode: response.status,
             responseBody,
             data: parsedError,
-            isRetryable: isRetryable?.(parsedError, response),
+            isRetryable: isRetryable?.(response, parsedError),
         });
     }
     catch (parseError) {
         return new ApiCallError({
-            message: responseBody.trim() !== "" ? responseBody : response.statusText,
+            message: response.statusText,
             url,
             requestBodyValues,
             statusCode: response.status,
             responseBody,
+            isRetryable: isRetryable?.(response),
         });
     }
 };
+export const createTextErrorResponseHandler = ({ isRetryable, } = {}) => async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    return new ApiCallError({
+        message: responseBody.trim() !== "" ? responseBody : response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseBody,
+        isRetryable: isRetryable?.(response),
+    });
+};
 export const createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
     const parsedResult = safeParseJSON({
         text: responseBody,
-        schema: new ZodSchema(responseSchema),
+        schema: responseSchema,
     });
     if (!parsedResult.success) {
         throw new ApiCallError({