@independo/inderun-web 0.1.0

package/dist/errors.js

@@ -0,0 +1,155 @@
+/**
+ * Standardized framework exception thrown when route selection or provider execution fails.
+ * Extends the native JavaScript Error class and exposes normalized error schema fields.
+ */
+export class IndeRunException extends Error {
+    /** The schema version matching the API contracts. */
+    schemaVersion = "1.0";
+    /** The categorized class of error. */
+    errorClass;
+    /** The unique execution run ID. */
+    runId;
+    /** The provider ID responsible for the error. */
+    providerId;
+    /** Whether the error is transient and retryable. */
+    retryable;
+    /** Suggested cooling-down time in milliseconds before retry. */
+    retryAfterMs;
+    /** Custom details and metadata context. */
+    details;
+    constructor(params) {
+        super(params.message);
+        this.name = "IndeRunException";
+        this.errorClass = params.errorClass;
+        if (params.runId !== undefined)
+            this.runId = params.runId;
+        if (params.providerId !== undefined)
+            this.providerId = params.providerId;
+        if (params.retryable !== undefined)
+            this.retryable = params.retryable;
+        if (params.retryAfterMs !== undefined)
+            this.retryAfterMs = params.retryAfterMs;
+        if (params.details !== undefined)
+            this.details = params.details;
+        Object.setPrototypeOf(this, IndeRunException.prototype);
+    }
+    /**
+     * Converts the exception into a JSON-compatible contract-compliant IndeRunError.
+     */
+    toContractError() {
+        const err = {
+            schemaVersion: this.schemaVersion,
+            errorClass: this.errorClass,
+            message: this.message
+        };
+        if (this.runId !== undefined)
+            err.runId = this.runId;
+        if (this.providerId !== undefined)
+            err.providerId = this.providerId;
+        if (this.retryable !== undefined)
+            err.retryable = this.retryable;
+        if (this.retryAfterMs !== undefined)
+            err.retryAfterMs = this.retryAfterMs;
+        if (this.details !== undefined)
+            err.details = this.details;
+        return err;
+    }
+}
+/**
+ * Factory helper for CapabilityMismatch error class.
+ */
+export function createCapabilityMismatch(message, extra) {
+    return new IndeRunException({ errorClass: "CapabilityMismatch", message, ...extra });
+}
+/**
+ * Factory helper for Offline error class.
+ */
+export function createOffline(message, extra) {
+    return new IndeRunException({ errorClass: "Offline", message, ...extra });
+}
+/**
+ * Factory helper for AuthError error class.
+ */
+export function createAuthError(message, extra) {
+    return new IndeRunException({ errorClass: "AuthError", message, ...extra });
+}
+/**
+ * Factory helper for RateLimited error class.
+ */
+export function createRateLimited(message, extra) {
+    return new IndeRunException({ errorClass: "RateLimited", message, ...extra });
+}
+/**
+ * Factory helper for Timeout error class.
+ */
+export function createTimeout(message, extra) {
+    return new IndeRunException({ errorClass: "Timeout", message, ...extra });
+}
+/**
+ * Factory helper for Unavailable error class.
+ */
+export function createUnavailable(message, extra) {
+    return new IndeRunException({ errorClass: "Unavailable", message, ...extra });
+}
+/**
+ * Factory helper for Internal error class.
+ */
+export function createInternal(message, extra) {
+    return new IndeRunException({ errorClass: "Internal", message, ...extra });
+}
+/**
+ * Standardizes any caught error into an IndeRunException.
+ * If the input error is already an IndeRunException, merges additional fallback parameters (like totalMs).
+ */
+export function toIndeRunException(error, fallbackParams) {
+    if (error instanceof IndeRunException) {
+        if (fallbackParams) {
+            const mergedParams = {
+                errorClass: error.errorClass,
+                message: error.message
+            };
+            const runId = error.runId ?? fallbackParams.runId;
+            if (runId !== undefined)
+                mergedParams.runId = runId;
+            const providerId = error.providerId ?? fallbackParams.providerId;
+            if (providerId !== undefined)
+                mergedParams.providerId = providerId;
+            const retryable = error.retryable ?? fallbackParams.retryable;
+            if (retryable !== undefined)
+                mergedParams.retryable = retryable;
+            const retryAfterMs = error.retryAfterMs ?? fallbackParams.retryAfterMs;
+            if (retryAfterMs !== undefined)
+                mergedParams.retryAfterMs = retryAfterMs;
+            if (error.details !== undefined || fallbackParams.details !== undefined) {
+                mergedParams.details = {
+                    ...(error.details || {}),
+                    ...(fallbackParams.details || {})
+                };
+            }
+            return new IndeRunException(mergedParams);
+        }
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const details = {
+        ...(fallbackParams?.details || {})
+    };
+    if (error instanceof Error) {
+        details.originalError = {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+        };
+    }
+    else {
+        details.originalError = {
+            message: String(error)
+        };
+    }
+    return new IndeRunException({
+        errorClass: "Internal",
+        message,
+        ...fallbackParams,
+        details
+    });
+}

package/dist/host.d.ts

@@ -0,0 +1,2 @@
+export type { ClockService, ConnectivityService, DeviceConstraintsService, HostServices, HttpClientService, HttpRequest, HttpResponse, SecureStorageService, TelemetryService, ThermalState } from "@independo/inderun-contracts";
+//# sourceMappingURL=host.d.ts.map

package/dist/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../src/host.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACb,MAAM,8BAA8B,CAAC"}

package/dist/host.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { type ConnectivityService, type DeviceConstraintsService, type SecureStorageService, type ClockService, type HttpClientService, type HttpRequest, type HttpResponse, type HostServices, type ThermalState } from "./host.js";
+export { type ProviderDescriptor, type ProviderDynamicCapabilities, type RunContext, type ProviderAdapter } from "./provider.js";
+export { ProviderRegistry } from "./registry.js";
+export { type RouteSelection, Router } from "./router.js";
+export { type RoutePlanner, type SharedPlannerInput, type SharedPlannerRoutePlan, WasmRoutePlanner } from "./route-planner.js";
+export { type IndeRunExceptionParams, IndeRunException, createCapabilityMismatch, createOffline, createAuthError, createRateLimited, createTimeout, createUnavailable, createInternal, toIndeRunException } from "./errors.js";
+export { IndeRun } from "./engine.js";
+export { type TelemetryEventType, type TelemetryEvent, type TelemetryService, NoOpTelemetryService } from "./telemetry.js";
+export { BrowserConnectivityService, FetchHttpClient, SystemClockService, createBrowserHostServices, type CreateBrowserHostServicesOptions, type FetchHttpClientOptions } from "./browser-host.js";
+export { createIndeRunWeb, type CreateIndeRunWebOptions } from "./web-sdk.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,UAAU,EACf,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,gBAAgB,EACjB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,wBAAwB,EACxB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,oBAAoB,EACrB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC5B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+export {} from "./host.js";
+export {} from "./provider.js";
+export { ProviderRegistry } from "./registry.js";
+export { Router } from "./router.js";
+export { WasmRoutePlanner } from "./route-planner.js";
+export { IndeRunException, createCapabilityMismatch, createOffline, createAuthError, createRateLimited, createTimeout, createUnavailable, createInternal, toIndeRunException } from "./errors.js";
+export { IndeRun } from "./engine.js";
+export { NoOpTelemetryService } from "./telemetry.js";
+export { BrowserConnectivityService, FetchHttpClient, SystemClockService, createBrowserHostServices } from "./browser-host.js";
+export { createIndeRunWeb } from "./web-sdk.js";
+// The OpenAI Responses adapter is provider-specific and intentionally excluded
+// from this unified index. Import it from "@independo/inderun-web/openai".

package/dist/openai-provider.d.ts

@@ -0,0 +1,80 @@
+import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
+import type { HostServices } from "./host.js";
+import type { ProviderAdapter, ProviderDescriptor, ProviderDynamicCapabilities, RunContext } from "./provider.js";
+export declare const DEFAULT_OPENAI_RESPONSES_ENDPOINT = "https://api.openai.com/v1/responses";
+/**
+ * Configuration for the OpenAI Responses provider.
+ */
+export interface OpenAIProviderOptions {
+    /**
+     * Provider id exposed in telemetry and routing explanations.
+     */
+    id?: string;
+    /**
+     * OpenAI model id sent to the Responses API.
+     */
+    model: string;
+    /**
+     * Responses-compatible endpoint. Use a same-origin proxy endpoint in browser apps.
+     */
+    endpointUrl?: string;
+    /**
+     * Authentication mode. Use "none" for browser proxy endpoints that resolve
+     * OpenAI credentials server-side.
+     */
+    auth?: "authContextRef" | "none";
+    /**
+     * Default secure-storage slot used when the request does not provide authContextRef.
+     */
+    authContextRef?: string;
+    /**
+     * Optional HTTP timeout for the host transport attempt.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Cloud provider adapter that executes Mode-1 text-to-text requests through the OpenAI Responses API.
+ *
+ * Browser applications should prefer a same-origin proxy endpoint with `auth: "none"` so OpenAI credentials
+ * stay server-side. Direct OpenAI authentication is available through `authContextRef` and `SecureStorageService`
+ * for controlled environments.
+ */
+export declare class OpenAIResponsesProvider implements ProviderAdapter {
+    private readonly options;
+    private readonly id;
+    private readonly endpointUrl;
+    private readonly auth;
+    /**
+     * Creates an OpenAI Responses provider.
+     * @param options - Provider configuration, including required OpenAI model id.
+     */
+    constructor(options: OpenAIProviderOptions);
+    /**
+     * Returns static metadata used by the router for deterministic provider selection.
+     */
+    describe(): ProviderDescriptor;
+    /**
+     * Reports dynamic provider availability for the current host.
+     * @param host - Host services available to the engine.
+     */
+    capabilities(host: HostServices): Promise<ProviderDynamicCapabilities>;
+    /**
+     * Executes a normalized text-to-text task using the OpenAI Responses API.
+     * @param request - Canonical IndeRun task request.
+     * @param context - Engine execution context containing run id and host services.
+     * @returns Normalized IndeRun task result.
+     * @throws IndeRunException mapped to the standard error taxonomy.
+     */
+    run(request: TaskRequest, context: RunContext): Promise<TaskResult>;
+    private createRequestBody;
+    /**
+     * Maps an OpenAI HTTP error response onto the IndeRun error taxonomy:
+     * - `401` / `403` → `AuthError`
+     * - `429` → `RateLimited` (honors `Retry-After` when present)
+     * - `408` / `504` → `Timeout`
+     * - `409` / `5xx` → `Unavailable`
+     * - any other non-2xx status → `Internal`
+     */
+    private mapHttpError;
+}
+//# sourceMappingURL=openai-provider.d.ts.map

package/dist/openai-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-provider.d.ts","sourceRoot":"","sources":["../src/openai-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAQ5E,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,2BAA2B,EAC3B,UAAU,EACX,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,iCAAiC,wCAAwC,CAAC;AAEvF;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IACjC;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAwBD;;;;;;GAMG;AACH,qBAAa,uBAAwB,YAAW,eAAe;IASjD,OAAO,CAAC,QAAQ,CAAC,OAAO;IARpC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IAEjD;;;OAGG;gBAC0B,OAAO,EAAE,qBAAqB;IAM3D;;OAEG;IACH,QAAQ,IAAI,kBAAkB;IAsB9B;;;OAGG;IACG,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAkB5E;;;;;;OAMG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAkHzE,OAAO,CAAC,iBAAiB;IAuBzB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;CAmErB"}

package/dist/openai-provider.js

@@ -0,0 +1,345 @@
+import { createAuthError, createInternal, createRateLimited, createTimeout, createUnavailable } from "./errors.js";
+export const DEFAULT_OPENAI_RESPONSES_ENDPOINT = "https://api.openai.com/v1/responses";
+/**
+ * Cloud provider adapter that executes Mode-1 text-to-text requests through the OpenAI Responses API.
+ *
+ * Browser applications should prefer a same-origin proxy endpoint with `auth: "none"` so OpenAI credentials
+ * stay server-side. Direct OpenAI authentication is available through `authContextRef` and `SecureStorageService`
+ * for controlled environments.
+ */
+export class OpenAIResponsesProvider {
+    options;
+    id;
+    endpointUrl;
+    auth;
+    /**
+     * Creates an OpenAI Responses provider.
+     * @param options - Provider configuration, including required OpenAI model id.
+     */
+    constructor(options) {
+        this.options = options;
+        this.id = options.id ?? "openai";
+        this.endpointUrl = options.endpointUrl ?? DEFAULT_OPENAI_RESPONSES_ENDPOINT;
+        this.auth = options.auth ?? "authContextRef";
+    }
+    /**
+     * Returns static metadata used by the router for deterministic provider selection.
+     */
+    describe() {
+        return {
+            id: this.id,
+            type: "cloud",
+            transport: "http",
+            supports: {
+                run: true,
+                streaming: false,
+                realtime: false,
+                tools: false,
+                reasoningEvents: false,
+                structuredOutput: false,
+                multimodal: false
+            },
+            cancel: "hard",
+            tasks: ["text_to_text"],
+            privacy: {
+                dataLeavesDevice: true
+            }
+        };
+    }
+    /**
+     * Reports dynamic provider availability for the current host.
+     * @param host - Host services available to the engine.
+     */
+    async capabilities(host) {
+        if (!host.httpClient) {
+            return {
+                available: false,
+                reason: "OpenAI Responses provider requires an HttpClientService."
+            };
+        }
+        if (this.auth !== "none" && !host.secureStorage) {
+            return {
+                available: false,
+                reason: "OpenAI Responses provider requires a SecureStorageService when auth is enabled."
+            };
+        }
+        return { available: true };
+    }
+    /**
+     * Executes a normalized text-to-text task using the OpenAI Responses API.
+     * @param request - Canonical IndeRun task request.
+     * @param context - Engine execution context containing run id and host services.
+     * @returns Normalized IndeRun task result.
+     * @throws IndeRunException mapped to the standard error taxonomy.
+     */
+    async run(request, context) {
+        const httpClient = context.hostServices.httpClient;
+        if (!httpClient) {
+            throw createUnavailable("OpenAI Responses provider requires an HTTP client.", {
+                providerId: this.id,
+                runId: context.runId
+            });
+        }
+        const headers = {
+            "Content-Type": "application/json"
+        };
+        if (this.auth === "authContextRef") {
+            const slotId = request.authContextRef ?? this.options.authContextRef;
+            if (!slotId) {
+                throw createAuthError("OpenAI Responses provider requires authContextRef.", {
+                    providerId: this.id,
+                    runId: context.runId
+                });
+            }
+            const secureStorage = context.hostServices.secureStorage;
+            if (!secureStorage) {
+                throw createAuthError("OpenAI Responses provider requires a SecureStorageService when auth is enabled.", {
+                    providerId: this.id,
+                    runId: context.runId
+                });
+            }
+            const secret = await secureStorage.getSecret(slotId);
+            if (!secret) {
+                throw createAuthError(`No OpenAI credential found for authContextRef '${slotId}'.`, {
+                    providerId: this.id,
+                    runId: context.runId
+                });
+            }
+            headers.Authorization = `Bearer ${secret}`;
+        }
+        let response;
+        try {
+            const httpRequest = {
+                method: "POST",
+                url: this.endpointUrl,
+                headers,
+                body: JSON.stringify(this.createRequestBody(request))
+            };
+            if (this.options.timeoutMs !== undefined) {
+                httpRequest.timeoutMs = this.options.timeoutMs;
+            }
+            response = await httpClient.send(httpRequest);
+        }
+        catch (err) {
+            if (isAbortError(err)) {
+                throw createTimeout("OpenAI Responses request timed out.", {
+                    providerId: this.id,
+                    runId: context.runId
+                });
+            }
+            throw createUnavailable("OpenAI Responses request failed before a response was received.", {
+                providerId: this.id,
+                runId: context.runId,
+                details: { originalError: getErrorSummary(err) }
+            });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw this.mapHttpError(response.status, response.statusText, response.headers, response.body, context);
+        }
+        const responseBody = parseJson(response.body);
+        const outputText = extractOutputText(responseBody);
+        if (outputText === undefined) {
+            throw createInternal("OpenAI Responses payload did not contain text output.", {
+                providerId: this.id,
+                runId: context.runId
+            });
+        }
+        const result = {
+            schemaVersion: "1.0",
+            runId: context.runId,
+            output: {
+                type: "text",
+                text: outputText
+            },
+            finishReason: getFinishReason(responseBody),
+            telemetry: {
+                providerUsed: this.id,
+                totalMs: 0
+            }
+        };
+        const usage = getUsage(responseBody);
+        if (usage) {
+            result.usage = usage;
+        }
+        return result;
+    }
+    createRequestBody(request) {
+        const body = {
+            model: this.options.model,
+            input: createInput(request)
+        };
+        const generation = request.generation;
+        if (generation?.maxOutputTokens !== undefined) {
+            body.max_output_tokens = generation.maxOutputTokens;
+        }
+        if (generation?.temperature !== undefined) {
+            body.temperature = generation.temperature;
+        }
+        if (generation?.topP !== undefined) {
+            body.top_p = generation.topP;
+        }
+        if (generation?.stop !== undefined) {
+            body.stop = generation.stop;
+        }
+        return body;
+    }
+    /**
+     * Maps an OpenAI HTTP error response onto the IndeRun error taxonomy:
+     * - `401` / `403` → `AuthError`
+     * - `429` → `RateLimited` (honors `Retry-After` when present)
+     * - `408` / `504` → `Timeout`
+     * - `409` / `5xx` → `Unavailable`
+     * - any other non-2xx status → `Internal`
+     */
+    mapHttpError(status, statusText, headers, body, context) {
+        const error = parseJson(body);
+        const message = getOpenAIErrorMessage(error, status, statusText);
+        const details = {
+            status,
+            statusText,
+            errorType: getString(error.error?.type),
+            errorCode: getString(error.error?.code)
+        };
+        if (status === 401 || status === 403) {
+            return createAuthError(message, {
+                providerId: this.id,
+                runId: context.runId,
+                details
+            });
+        }
+        if (status === 429) {
+            const retryAfterMs = parseRetryAfterMs(headers);
+            const params = {
+                providerId: this.id,
+                runId: context.runId,
+                retryable: true,
+                details
+            };
+            if (retryAfterMs !== undefined) {
+                return createRateLimited(message, {
+                    ...params,
+                    retryAfterMs
+                });
+            }
+            return createRateLimited(message, params);
+        }
+        if (status === 408 || status === 504) {
+            return createTimeout(message, {
+                providerId: this.id,
+                runId: context.runId,
+                retryable: true,
+                details
+            });
+        }
+        if (status === 409 || status >= 500) {
+            return createUnavailable(message, {
+                providerId: this.id,
+                runId: context.runId,
+                retryable: true,
+                details
+            });
+        }
+        return createInternal(message, {
+            providerId: this.id,
+            runId: context.runId,
+            details
+        });
+    }
+}
+function createInput(request) {
+    if (request.messages && request.messages.length > 0) {
+        return request.messages.map((message) => ({
+            role: message.role === "system" ? "developer" : message.role,
+            content: message.content
+        }));
+    }
+    return request.prompt ?? "";
+}
+function extractOutputText(response) {
+    if (typeof response.output_text === "string") {
+        return response.output_text;
+    }
+    if (!Array.isArray(response.output)) {
+        return undefined;
+    }
+    const textParts = [];
+    for (const item of response.output) {
+        if (!isRecord(item) || !Array.isArray(item.content)) {
+            continue;
+        }
+        for (const contentItem of item.content) {
+            if (isRecord(contentItem) &&
+                contentItem.type === "output_text" &&
+                typeof contentItem.text === "string") {
+                textParts.push(contentItem.text);
+            }
+        }
+    }
+    return textParts.length > 0 ? textParts.join("") : undefined;
+}
+function getFinishReason(response) {
+    if (response.status === "incomplete") {
+        return response.incomplete_details?.reason === "max_output_tokens" ? "length" : "error";
+    }
+    return "stop";
+}
+function getUsage(response) {
+    const usage = {};
+    if (typeof response.usage?.input_tokens === "number") {
+        usage.inputTokens = response.usage.input_tokens;
+    }
+    if (typeof response.usage?.output_tokens === "number") {
+        usage.outputTokens = response.usage.output_tokens;
+    }
+    if (typeof response.usage?.total_tokens === "number") {
+        usage.totalTokens = response.usage.total_tokens;
+    }
+    return Object.keys(usage).length > 0 ? usage : undefined;
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return {};
+    }
+}
+function getOpenAIErrorMessage(response, status, statusText) {
+    if (typeof response.error?.message === "string" && response.error.message.length > 0) {
+        return response.error.message;
+    }
+    return `OpenAI Responses request failed with HTTP ${status} ${statusText}.`;
+}
+function parseRetryAfterMs(headers) {
+    const raw = headers["retry-after"] ?? headers["Retry-After"];
+    if (!raw) {
+        return undefined;
+    }
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const dateMs = Date.parse(raw);
+    if (Number.isFinite(dateMs)) {
+        return Math.max(0, dateMs - Date.now());
+    }
+    return undefined;
+}
+function isAbortError(error) {
+    return isRecord(error) && getString(error.name) === "AbortError";
+}
+function getErrorSummary(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message
+        };
+    }
+    return { message: String(error) };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object";
+}
+function getString(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/openai.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Provider-specific entry point for the OpenAI Responses adapter.
+ *
+ * Kept out of the unified SDK index (`@independo/inderun-web`) so the top-level
+ * surface stays provider-agnostic. Import from `@independo/inderun-web/openai`
+ * when registering the adapter manually; most browser apps should use
+ * `createIndeRunWeb` from the main entry point instead.
+ */
+export { OpenAIResponsesProvider, type OpenAIProviderOptions, DEFAULT_OPENAI_RESPONSES_ENDPOINT } from "./openai-provider.js";
+//# sourceMappingURL=openai.d.ts.map

package/dist/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../src/openai.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,iCAAiC,EAClC,MAAM,sBAAsB,CAAC"}

package/dist/openai.js

@@ -0,0 +1,9 @@
+/**
+ * Provider-specific entry point for the OpenAI Responses adapter.
+ *
+ * Kept out of the unified SDK index (`@independo/inderun-web`) so the top-level
+ * surface stays provider-agnostic. Import from `@independo/inderun-web/openai`
+ * when registering the adapter manually; most browser apps should use
+ * `createIndeRunWeb` from the main entry point instead.
+ */
+export { OpenAIResponsesProvider, DEFAULT_OPENAI_RESPONSES_ENDPOINT } from "./openai-provider.js";