@openrouter/sdk 1.3.20 → 1.3.22

package/esm/funcs/imagesGenerate.js

@@ -9,14 +9,14 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as operations from "../models/operations/index.js";
+import { BadGatewayResponseError$inboundSchema as errors_BadGatewayResponseError$inboundSchema } from "../models/errors/badgatewayresponseerror.js"; import { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { EdgeNetworkTimeoutResponseError$inboundSchema as errors_EdgeNetworkTimeoutResponseError$inboundSchema } from "../models/errors/edgenetworktimeoutresponseerror.js"; import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js"; import { PayloadTooLargeResponseError$inboundSchema as errors_PayloadTooLargeResponseError$inboundSchema } from "../models/errors/payloadtoolargeresponseerror.js"; import { PaymentRequiredResponseError$inboundSchema as errors_PaymentRequiredResponseError$inboundSchema } from "../models/errors/paymentrequiredresponseerror.js"; import { ProviderOverloadedResponseError$inboundSchema as errors_ProviderOverloadedResponseError$inboundSchema } from "../models/errors/provideroverloadedresponseerror.js"; import { TooManyRequestsResponseError$inboundSchema as errors_TooManyRequestsResponseError$inboundSchema } from "../models/errors/toomanyrequestsresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { CreateImagesRequest$outboundSchema as operations_CreateImagesRequest$outboundSchema, CreateImagesResponse$inboundSchema as operations_CreateImagesResponse$inboundSchema } from "../models/operations/createimages.js";
 import { APIPromise } from "../types/async.js";
 export function imagesGenerate(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.CreateImagesRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_CreateImagesRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -86,7 +86,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.CreateImagesResponse$inboundSchema), M.sse(200, operations.CreateImagesResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors.PaymentRequiredResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(413, errors.PayloadTooLargeResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(524, errors.EdgeNetworkTimeoutResponseError$inboundSchema), M.jsonErr(529, errors.ProviderOverloadedResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, operations_CreateImagesResponse$inboundSchema), M.sse(200, operations_CreateImagesResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors_PaymentRequiredResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$inboundSchema), M.jsonErr(413, errors_PayloadTooLargeResponseError$inboundSchema), M.jsonErr(429, errors_TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.jsonErr(502, errors_BadGatewayResponseError$inboundSchema), M.jsonErr(524, errors_EdgeNetworkTimeoutResponseError$inboundSchema), M.jsonErr(529, errors_ProviderOverloadedResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/imagesListModelEndpoints.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js";
+import { ImageModelEndpointsResponse$inboundSchema as models_ImageModelEndpointsResponse$inboundSchema } from "../models/imagemodelendpointsresponse.js";
+import { ListImageModelEndpointsRequest$outboundSchema as operations_ListImageModelEndpointsRequest$outboundSchema } from "../models/operations/listimagemodelendpoints.js";
 import { APIPromise } from "../types/async.js";
 /**
  * List endpoints for an image model
@@ -23,7 +23,7 @@ export function imagesListModelEndpoints(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListImageModelEndpointsRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListImageModelEndpointsRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -98,7 +98,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ImageModelEndpointsResponse$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_ImageModelEndpointsResponse$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/imagesListModels.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js";
+import { ImageModelsListResponse$inboundSchema as models_ImageModelsListResponse$inboundSchema } from "../models/imagemodelslistresponse.js";
+import { ListImageModelsRequest$outboundSchema as operations_ListImageModelsRequest$outboundSchema } from "../models/operations/listimagemodels.js";
 import { APIPromise } from "../types/async.js";
 /**
  * List image generation models
@@ -23,7 +23,7 @@ export function imagesListModels(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListImageModelsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListImageModelsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -88,7 +88,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ImageModelsListResponse$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_ImageModelsListResponse$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsChat.js

@@ -9,14 +9,14 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternChatErrorResponse$inboundSchema as errors_InternChatErrorResponse$inboundSchema } from "../models/errors/internchaterrorresponse.js";
+import { CreateInternChatCompletionRequest$outboundSchema as operations_CreateInternChatCompletionRequest$outboundSchema, CreateInternChatCompletionResponse$inboundSchema as operations_CreateInternChatCompletionResponse$inboundSchema } from "../models/operations/createinternchatcompletion.js";
 import { APIPromise } from "../types/async.js";
 export function internsChat(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.CreateInternChatCompletionRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_CreateInternChatCompletionRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -92,15 +92,15 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.sse(200, operations.CreateInternChatCompletionResponse$inboundSchema, {
+    const [result] = await M.match(M.sse(200, operations_CreateInternChatCompletionResponse$inboundSchema, {
         key: "Result",
-    }), M.json(202, operations.CreateInternChatCompletionResponse$inboundSchema, {
+    }), M.json(202, operations_CreateInternChatCompletionResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr([400, 401, 403, 404, 408, 410, 413], errors.InternChatErrorResponse$inboundSchema), M.jsonErr([409, 429], errors.InternChatErrorResponse$inboundSchema, {
+    }), M.jsonErr([400, 401, 403, 404, 408, 410, 413], errors_InternChatErrorResponse$inboundSchema), M.jsonErr([409, 429], errors_InternChatErrorResponse$inboundSchema, {
         hdrs: true,
-    }), M.jsonErr(503, errors.InternChatErrorResponse$inboundSchema, {
+    }), M.jsonErr(503, errors_InternChatErrorResponse$inboundSchema, {
         hdrs: true,
-    }), M.jsonErr([502, 504], errors.InternChatErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    }), M.jsonErr([502, 504], errors_InternChatErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsCreateIntern.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { Intern$inboundSchema as models_Intern$inboundSchema } from "../models/intern.js";
+import { CreateInternRequest$outboundSchema as operations_CreateInternRequest$outboundSchema } from "../models/operations/createintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Create an intern
@@ -25,7 +25,7 @@ export function internsCreateIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.CreateInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_CreateInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -94,7 +94,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json([200, 201], models.Intern$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json([200, 201], models_Intern$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsDeleteIntern.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { DeleteInternResponse$inboundSchema as models_DeleteInternResponse$inboundSchema } from "../models/deleteinternresponse.js";
+import { DeleteInternRequest$outboundSchema as operations_DeleteInternRequest$outboundSchema } from "../models/operations/deleteintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Delete an intern
@@ -25,7 +25,7 @@ export function internsDeleteIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.DeleteInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_DeleteInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -99,7 +99,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(202, models.DeleteInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(202, models_DeleteInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsGetIntern.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { Intern$inboundSchema as models_Intern$inboundSchema } from "../models/intern.js";
+import { GetInternRequest$outboundSchema as operations_GetInternRequest$outboundSchema } from "../models/operations/getintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Get an intern
@@ -25,7 +25,7 @@ export function internsGetIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.GetInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_GetInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -96,7 +96,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.Intern$inboundSchema), M.jsonErr([401, 403, 404, 408], errors.InternLifecycleError$inboundSchema), M.jsonErr(500, errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_Intern$inboundSchema), M.jsonErr([401, 403, 404, 408], errors_InternLifecycleError$inboundSchema), M.jsonErr(500, errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsInvoke.d.ts

@@ -0,0 +1,26 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { OpenRouterError } from "../models/errors/openroutererror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * Start an intern run without waiting for it
+ *
+ * @remarks
+ * Starts a run on one of your interns and answers `202` with the `session_id` as soon as the intern accepts it. The run keeps going on the intern after the response. Nothing about its progress comes back on this request; the intern reports through its own tools, such as Slack.
+ *
+ * Send the same `session_id` later to continue the conversation, for example to hand the intern a decision on work it started. If that session already has a run going, the prompt is delivered into it and the status is `steered`. A `session_id` is accepted only from the caller it was issued to, on the same intern; any other, including sessions started from Slack or the chat endpoint, is refused with `404`.
+ *
+ * Runs started here self-drive: the intern consents to its own tool approvals, and a question it asks is answered by its own fallback. A run ends when the intern finishes it or after its execution deadline (1 hour by default).
+ *
+ * Available to interns programme members. Callers outside the programme receive `404` for every path under `/api/v1/interns`.
+ *
+ * If set, this operation will use {@link Security.apiKey} from the global security.
+ */
+export declare function internsInvoke(client: OpenRouterCore, request: operations.InvokeInternRequest, options?: RequestOptions): APIPromise<Result<operations.InvokeInternResponse, errors.InternChatErrorResponse | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+//# sourceMappingURL=internsInvoke.d.ts.map

package/esm/funcs/internsInvoke.js

@@ -0,0 +1,119 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d0be40cd89cf
+ */
+import { encodeJSON, encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import { InternChatErrorResponse$inboundSchema as errors_InternChatErrorResponse$inboundSchema } from "../models/errors/internchaterrorresponse.js";
+import { InvokeInternRequest$outboundSchema as operations_InvokeInternRequest$outboundSchema, InvokeInternResponse$inboundSchema as operations_InvokeInternResponse$inboundSchema } from "../models/operations/invokeintern.js";
+import { APIPromise } from "../types/async.js";
+/**
+ * Start an intern run without waiting for it
+ *
+ * @remarks
+ * Starts a run on one of your interns and answers `202` with the `session_id` as soon as the intern accepts it. The run keeps going on the intern after the response. Nothing about its progress comes back on this request; the intern reports through its own tools, such as Slack.
+ *
+ * Send the same `session_id` later to continue the conversation, for example to hand the intern a decision on work it started. If that session already has a run going, the prompt is delivered into it and the status is `steered`. A `session_id` is accepted only from the caller it was issued to, on the same intern; any other, including sessions started from Slack or the chat endpoint, is refused with `404`.
+ *
+ * Runs started here self-drive: the intern consents to its own tool approvals, and a question it asks is answered by its own fallback. A run ends when the intern finishes it or after its execution deadline (1 hour by default).
+ *
+ * Available to interns programme members. Callers outside the programme receive `404` for every path under `/api/v1/interns`.
+ *
+ * If set, this operation will use {@link Security.apiKey} from the global security.
+ */
+export function internsInvoke(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => operations_InvokeInternRequest$outboundSchema.parse(value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = encodeJSON("body", payload.InternInvokeRequest, {
+        explode: true,
+    });
+    const pathParams = {
+        internId: encodeSimple("internId", payload.internId, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/interns/{internId}/invoke")(pathParams);
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),
+        "X-OpenRouter-Categories": encodeSimple("X-OpenRouter-Categories", payload.appCategories ?? client._options.appCategories, { explode: false, charEncoding: "none" }),
+        "X-OpenRouter-Title": encodeSimple("X-OpenRouter-Title", payload.appTitle ?? client._options.appTitle, { explode: false, charEncoding: "none" }),
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput, [0]);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "invokeIntern",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["5XX"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "POST",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        body: body,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(202, operations_InvokeInternResponse$inboundSchema, {
+        key: "Result",
+    }), M.jsonErr([400, 401, 403, 404, 408, 413], errors_InternChatErrorResponse$inboundSchema), M.jsonErr([409, 429], errors_InternChatErrorResponse$inboundSchema, {
+        hdrs: true,
+    }), M.jsonErr(503, errors_InternChatErrorResponse$inboundSchema, {
+        hdrs: true,
+    }), M.jsonErr([500, 502, 504], errors_InternChatErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return [result, { status: "complete", request: req, response }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}
+//# sourceMappingURL=internsInvoke.js.map

package/esm/funcs/internsListInterns.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { InternListResponse$inboundSchema as models_InternListResponse$inboundSchema } from "../models/internlistresponse.js";
+import { ListInternsRequest$outboundSchema as operations_ListInternsRequest$outboundSchema } from "../models/operations/listinterns.js";
 import { APIPromise } from "../types/async.js";
 /**
  * List interns
@@ -25,7 +25,7 @@ export function internsListInterns(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListInternsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListInternsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -98,7 +98,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.InternListResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408], errors.InternLifecycleError$inboundSchema), M.jsonErr(500, errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_InternListResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408], errors_InternLifecycleError$inboundSchema), M.jsonErr(500, errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsProvisionIntern.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { ProvisionInternResponse$inboundSchema as models_ProvisionInternResponse$inboundSchema } from "../models/provisioninternresponse.js";
+import { ProvisionInternRequest$outboundSchema as operations_ProvisionInternRequest$outboundSchema } from "../models/operations/provisionintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Provision an intern
@@ -25,7 +25,7 @@ export function internsProvisionIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ProvisionInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ProvisionInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -96,7 +96,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(202, models.ProvisionInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(202, models_ProvisionInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsSuspendIntern.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { SuspendInternResponse$inboundSchema as models_SuspendInternResponse$inboundSchema } from "../models/suspendinternresponse.js";
+import { SuspendInternRequest$outboundSchema as operations_SuspendInternRequest$outboundSchema } from "../models/operations/suspendintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Suspend an intern
@@ -25,7 +25,7 @@ export function internsSuspendIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.SuspendInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_SuspendInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -96,7 +96,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.SuspendInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_SuspendInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsUpdateIntern.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { Intern$inboundSchema as models_Intern$inboundSchema } from "../models/intern.js";
+import { UpdateInternRequest$outboundSchema as operations_UpdateInternRequest$outboundSchema } from "../models/operations/updateintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Update an intern
@@ -25,7 +25,7 @@ export function internsUpdateIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.UpdateInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_UpdateInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -99,7 +99,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.Intern$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr(500, errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_Intern$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr(500, errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/modelsCount.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js";
+import { ModelsCountResponse$inboundSchema as models_ModelsCountResponse$inboundSchema } from "../models/modelscountresponse.js";
+import { ListModelsCountRequest$outboundSchema as operations_ListModelsCountRequest$outboundSchema } from "../models/operations/listmodelscount.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Get total count of available models
@@ -20,7 +20,7 @@ export function modelsCount(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListModelsCountRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListModelsCountRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -89,7 +89,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ModelsCountResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_ModelsCountResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/modelsGet.js

@@ -9,9 +9,9 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js";
+import { ModelResponse$inboundSchema as models_ModelResponse$inboundSchema } from "../models/modelresponse.js";
+import { GetModelRequest$outboundSchema as operations_GetModelRequest$outboundSchema } from "../models/operations/getmodel.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Get a model by its slug
@@ -23,7 +23,7 @@ export function modelsGet(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.GetModelRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_GetModelRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -98,7 +98,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ModelResponse$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_ModelResponse$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/modelsList.js

@@ -9,8 +9,8 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
-import * as errors from "../models/errors/index.js";
-import * as operations from "../models/operations/index.js";
+import { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js";
+import { GetModelsRequest$outboundSchema as operations_GetModelsRequest$outboundSchema, GetModelsResponse$inboundSchema as operations_GetModelsResponse$inboundSchema } from "../models/operations/getmodels.js";
 import { APIPromise } from "../types/async.js";
 import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
@@ -20,7 +20,7 @@ export function modelsList(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.GetModelsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_GetModelsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [haltIterator(parsed), { status: "invalid" }];
     }
@@ -117,7 +117,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.GetModelsResponse$inboundSchema, { key: "Result" }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result, raw] = await M.match(M.json(200, operations_GetModelsResponse$inboundSchema, { key: "Result" }), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [haltIterator(result), {
                 status: "complete",