@xfey/tenso 0.1.130

package/dist/providers/openai/provider-config-toml.js

@@ -0,0 +1,113 @@
+import { OPENAI_PROVIDER } from "./model-config.js";
+import { OpenAiProviderConfigError } from "./provider-config-errors.js";
+const CONFIG_TOML_SCHEMA_VERSION = 1;
+const CONFIG_ROOT_KEYS = new Set(["schema_version"]);
+const CONFIG_SECTIONS = new Set(["provider.openai"]);
+const PROJECT_OPENAI_TOML_KEYS = new Set([
+    "auth_kind",
+    "credential_ref",
+    "redacted_key",
+    "default_model",
+    "base_url",
+    "organization_id",
+    "openai_project_id",
+    "validated_at",
+]);
+function parseTomlScalar(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).replace(/\\"/gu, '"').replace(/\\\\/gu, "\\");
+    }
+    const parsed = Number(trimmed);
+    if (Number.isInteger(parsed)) {
+        return parsed;
+    }
+    throw new OpenAiProviderConfigError("toml_parse_failed");
+}
+export function parseTuttiConfigToml(raw) {
+    const document = {
+        root: {},
+        sections: {},
+    };
+    let currentSection = null;
+    for (const rawLine of raw.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (line === "" || line.startsWith("#")) {
+            continue;
+        }
+        const sectionMatch = /^\[([A-Za-z0-9_.-]+)\]$/u.exec(line);
+        if (sectionMatch !== null) {
+            const sectionName = sectionMatch[1];
+            if (sectionName === undefined) {
+                throw new OpenAiProviderConfigError("toml_parse_failed");
+            }
+            currentSection = sectionName;
+            document.sections[currentSection] ??= {};
+            continue;
+        }
+        const assignmentMatch = /^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/u.exec(line);
+        const key = assignmentMatch?.[1];
+        const rawValue = assignmentMatch?.[2];
+        if (key === undefined || rawValue === undefined) {
+            throw new OpenAiProviderConfigError("toml_parse_failed");
+        }
+        const target = currentSection === null ? document.root : (document.sections[currentSection] ??= {});
+        target[key] = parseTomlScalar(rawValue);
+    }
+    return document;
+}
+function assertTomlKeys(value, allowedKeys) {
+    for (const key of Object.keys(value)) {
+        if (!allowedKeys.has(key)) {
+            throw new OpenAiProviderConfigError("unknown_field", key);
+        }
+    }
+}
+export function parseTomlOpenAiSection(options) {
+    assertTomlKeys(options.document.root, CONFIG_ROOT_KEYS);
+    if (options.document.root.schema_version !== CONFIG_TOML_SCHEMA_VERSION) {
+        throw new OpenAiProviderConfigError("invalid_field", "schema_version");
+    }
+    for (const section of Object.keys(options.document.sections)) {
+        if (!CONFIG_SECTIONS.has(section)) {
+            throw new OpenAiProviderConfigError("unknown_field", section);
+        }
+    }
+    const openAiSection = options.document.sections["provider.openai"];
+    if (openAiSection === undefined) {
+        throw new OpenAiProviderConfigError("invalid_provider", "provider.openai");
+    }
+    assertTomlKeys(openAiSection, PROJECT_OPENAI_TOML_KEYS);
+    return {
+        provider: OPENAI_PROVIDER,
+        auth_kind: openAiSection.auth_kind,
+        credential_ref: openAiSection.credential_ref,
+        redacted_key: openAiSection.redacted_key,
+        default_model: openAiSection.default_model,
+        api_base_url: openAiSection.base_url,
+        organization_id: openAiSection.organization_id,
+        openai_project_id: openAiSection.openai_project_id,
+        validated_at: openAiSection.validated_at,
+    };
+}
+function tomlString(value) {
+    return `"${value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"')}"`;
+}
+function appendTomlString(lines, key, value) {
+    if (value !== undefined) {
+        lines.push(`${key} = ${tomlString(value)}`);
+    }
+}
+export function formatProjectOpenAiProviderConfig(config) {
+    const lines = ["schema_version = 1", "", "[provider.openai]"];
+    lines.push(`auth_kind = ${tomlString(config.auth_kind)}`);
+    lines.push(`credential_ref = ${tomlString(config.credential_ref)}`);
+    lines.push(`redacted_key = ${tomlString(config.redacted_key)}`);
+    lines.push(`default_model = ${tomlString(config.default_model)}`);
+    appendTomlString(lines, "base_url", config.api_base_url);
+    appendTomlString(lines, "organization_id", config.organization_id);
+    appendTomlString(lines, "openai_project_id", config.openai_project_id);
+    lines.push(`validated_at = ${tomlString(config.validated_at)}`);
+    return `${lines.join("\n")}\n`;
+}
+//# sourceMappingURL=provider-config-toml.js.map

package/dist/providers/openai/provider-config.d.ts

@@ -0,0 +1,77 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type OpenAiCredentialRef } from "./credential-store.js";
+import type { OPENAI_API_KEY_AUTH_KIND, OPENAI_PROVIDER } from "./model-config.js";
+import { OpenAiProviderConfigError } from "./provider-config-errors.js";
+export { OpenAiProviderConfigError } from "./provider-config-errors.js";
+export { parseOpenAiProviderConfig } from "./provider-config-shape.js";
+export type OpenAiProviderConfig = {
+    provider: typeof OPENAI_PROVIDER;
+    auth_kind: typeof OPENAI_API_KEY_AUTH_KIND;
+    credential_ref: OpenAiCredentialRef;
+    redacted_key: string;
+    validated_at: string;
+    default_model: string;
+    api_base_url?: string;
+    organization_id?: string;
+    openai_project_id?: string;
+};
+export type RedactedOpenAiProviderConfigProjection = {
+    status: "configured";
+    provider: typeof OPENAI_PROVIDER;
+    auth_kind: typeof OPENAI_API_KEY_AUTH_KIND;
+    redacted_key: string;
+    default_model: string;
+    validated_at: string;
+};
+export type OpenAiProviderConfigProjection = {
+    status: "not_configured";
+} | RedactedOpenAiProviderConfigProjection | {
+    status: "invalid";
+    provider?: typeof OPENAI_PROVIDER;
+    auth_kind?: typeof OPENAI_API_KEY_AUTH_KIND;
+    redacted_key?: string;
+    default_model?: string;
+    validated_at?: string;
+    invalid_reason_code?: "unknown";
+};
+export type ProviderConfigReadResult<TConfig> = {
+    kind: "missing";
+    source_path: string;
+} | {
+    kind: "invalid";
+    source_path: string;
+    error: OpenAiProviderConfigError;
+} | {
+    kind: "ok";
+    source_path: string;
+    config: TConfig;
+};
+export type OpenAiProviderConfigResolution = {
+    kind: "project_config";
+    source_path: string;
+    config: OpenAiProviderConfig;
+} | {
+    kind: "unavailable";
+    reason: "project_config_missing" | "project_config_invalid" | "project_credential_missing";
+    source_path?: string;
+    error?: OpenAiProviderConfigError;
+};
+export declare function resolveTuttiHome(input: string | undefined, cwd?: string): string;
+export declare function getProjectProviderConfigPath(tuttiHome: string, projectId: ProjectId): string;
+export declare function withProjectOpenAiProviderConfigLock<T>(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+}, operation: () => Promise<T>): Promise<T>;
+export declare function readProjectOpenAiProviderConfig(tuttiHome: string, projectId: ProjectId): ProviderConfigReadResult<OpenAiProviderConfig>;
+export declare function resolveOpenAiProviderConfig(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+    credentialExists?: (tuttiHome: string, projectId: ProjectId, credentialRef: OpenAiCredentialRef) => boolean;
+}): OpenAiProviderConfigResolution;
+export declare function writeProjectOpenAiProviderConfig(tuttiHome: string, projectId: ProjectId, config: OpenAiProviderConfig): void;
+export declare function createRedactedOpenAiProviderConfigProjection(config: OpenAiProviderConfig): RedactedOpenAiProviderConfigProjection;
+export declare function readOpenAiProviderConfigProjection(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+}): OpenAiProviderConfigProjection;
+//# sourceMappingURL=provider-config.d.ts.map

package/dist/providers/openai/provider-config.js

@@ -0,0 +1,138 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { openAiCredentialExists } from "./credential-store.js";
+import { readTextFile, writePrivateTextFileAtomically } from "./machine-local-files.js";
+import { OpenAiProviderConfigError } from "./provider-config-errors.js";
+import { parseOpenAiProviderConfig } from "./provider-config-shape.js";
+import { formatProjectOpenAiProviderConfig, parseTomlOpenAiSection, parseTuttiConfigToml, } from "./provider-config-toml.js";
+export { OpenAiProviderConfigError } from "./provider-config-errors.js";
+export { parseOpenAiProviderConfig } from "./provider-config-shape.js";
+export function resolveTuttiHome(input, cwd = process.cwd()) {
+    if (input === undefined || input.trim() === "") {
+        return join(homedir(), ".tutti");
+    }
+    const trimmed = input.trim();
+    if (trimmed === "~") {
+        return homedir();
+    }
+    if (trimmed.startsWith("~/")) {
+        return join(homedir(), trimmed.slice(2));
+    }
+    return isAbsolute(trimmed) ? resolve(trimmed) : resolve(cwd, trimmed);
+}
+export function getProjectProviderConfigPath(tuttiHome, projectId) {
+    return join(tuttiHome, "projects", projectId, "config.toml");
+}
+const providerConfigMutationTails = new Map();
+export async function withProjectOpenAiProviderConfigLock(options, operation) {
+    const key = getProjectProviderConfigPath(options.tuttiHome, options.projectId);
+    const previous = providerConfigMutationTails.get(key) ?? Promise.resolve();
+    let release = () => { };
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    const tail = previous.then(() => current);
+    providerConfigMutationTails.set(key, tail);
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (providerConfigMutationTails.get(key) === tail) {
+            providerConfigMutationTails.delete(key);
+        }
+    }
+}
+export function readProjectOpenAiProviderConfig(tuttiHome, projectId) {
+    const sourcePath = getProjectProviderConfigPath(tuttiHome, projectId);
+    const readResult = readTextFile(sourcePath);
+    if (readResult.kind === "missing") {
+        return { kind: "missing", source_path: sourcePath };
+    }
+    try {
+        return {
+            kind: "ok",
+            source_path: sourcePath,
+            config: parseOpenAiProviderConfig(parseTomlOpenAiSection({
+                document: parseTuttiConfigToml(readResult.value),
+            })),
+        };
+    }
+    catch (error) {
+        if (error instanceof OpenAiProviderConfigError) {
+            return { kind: "invalid", source_path: sourcePath, error };
+        }
+        throw error;
+    }
+}
+export function resolveOpenAiProviderConfig(options) {
+    const credentialExists = options.credentialExists ?? openAiCredentialExists;
+    const projectConfig = readProjectOpenAiProviderConfig(options.tuttiHome, options.projectId);
+    if (projectConfig.kind === "invalid") {
+        return {
+            kind: "unavailable",
+            reason: "project_config_invalid",
+            source_path: projectConfig.source_path,
+            error: projectConfig.error,
+        };
+    }
+    if (projectConfig.kind === "ok") {
+        if (!credentialExists(options.tuttiHome, options.projectId, projectConfig.config.credential_ref)) {
+            return {
+                kind: "unavailable",
+                reason: "project_credential_missing",
+                source_path: projectConfig.source_path,
+            };
+        }
+        return {
+            kind: "project_config",
+            source_path: projectConfig.source_path,
+            config: projectConfig.config,
+        };
+    }
+    return {
+        kind: "unavailable",
+        reason: "project_config_missing",
+        source_path: projectConfig.source_path,
+    };
+}
+export function writeProjectOpenAiProviderConfig(tuttiHome, projectId, config) {
+    writePrivateTextFileAtomically(getProjectProviderConfigPath(tuttiHome, projectId), formatProjectOpenAiProviderConfig(config));
+}
+export function createRedactedOpenAiProviderConfigProjection(config) {
+    const projection = {
+        status: "configured",
+        provider: config.provider,
+        auth_kind: config.auth_kind,
+        redacted_key: config.redacted_key,
+        default_model: config.default_model,
+        validated_at: config.validated_at,
+    };
+    return projection;
+}
+export function readOpenAiProviderConfigProjection(options) {
+    const resolution = resolveOpenAiProviderConfig(options);
+    if (resolution.kind === "project_config") {
+        return createRedactedOpenAiProviderConfigProjection(resolution.config);
+    }
+    if (resolution.reason === "project_config_missing") {
+        return { status: "not_configured" };
+    }
+    const projection = {
+        status: "invalid",
+        invalid_reason_code: "unknown",
+    };
+    if (resolution.reason === "project_credential_missing") {
+        const config = readProjectOpenAiProviderConfig(options.tuttiHome, options.projectId);
+        if (config.kind === "ok") {
+            projection.provider = config.config.provider;
+            projection.auth_kind = config.config.auth_kind;
+            projection.redacted_key = config.config.redacted_key;
+            projection.default_model = config.config.default_model;
+            projection.validated_at = config.config.validated_at;
+        }
+    }
+    return projection;
+}
+//# sourceMappingURL=provider-config.js.map

package/dist/providers/openai/provider-models.d.ts

@@ -0,0 +1,41 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type OpenAiCredentialValidationFailureReason, type OpenAiCredentialValidationInput, type OpenAiCredentialValidationResult, type OpenAiModelDiscoveryInput, type OpenAiModelDiscoveryResult } from "./credential-validation.js";
+import { type RedactedOpenAiProviderConfigProjection } from "./provider-config.js";
+export type ProjectOpenAiProviderUnavailableReason = "provider_not_configured" | "provider_config_invalid" | "provider_credential_missing";
+export type ProjectOpenAiModelDiscoveryResult = OpenAiModelDiscoveryResult | {
+    kind: "unavailable";
+    reason: ProjectOpenAiProviderUnavailableReason;
+};
+export type UpdateProjectOpenAiDefaultModelResult = {
+    kind: "updated";
+    projection: RedactedOpenAiProviderConfigProjection;
+} | {
+    kind: "unchanged";
+    projection: RedactedOpenAiProviderConfigProjection;
+} | {
+    kind: "stale_default_model";
+    current_default_model: string;
+} | {
+    kind: "validation_failed";
+    reason: OpenAiCredentialValidationFailureReason;
+    retryable: boolean;
+} | {
+    kind: "provider_unavailable";
+    reason: ProjectOpenAiProviderUnavailableReason;
+};
+export type DiscoverProjectOpenAiModelsOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    discoverModels?: (input: OpenAiModelDiscoveryInput) => Promise<OpenAiModelDiscoveryResult>;
+};
+export type UpdateProjectOpenAiDefaultModelOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    defaultModel: string;
+    expectedDefaultModel: string;
+    now?: () => Date;
+    validateCredential?: (input: OpenAiCredentialValidationInput) => Promise<OpenAiCredentialValidationResult>;
+};
+export declare function discoverProjectOpenAiModels(options: DiscoverProjectOpenAiModelsOptions): Promise<ProjectOpenAiModelDiscoveryResult>;
+export declare function updateProjectOpenAiDefaultModel(options: UpdateProjectOpenAiDefaultModelOptions): Promise<UpdateProjectOpenAiDefaultModelResult>;
+//# sourceMappingURL=provider-models.d.ts.map

package/dist/providers/openai/provider-models.js

@@ -0,0 +1,82 @@
+import { readOpenAiApiKeyCredential } from "./credential-store.js";
+import { discoverOpenAiModels, validateOpenAiCredential, } from "./credential-validation.js";
+import { createRedactedOpenAiProviderConfigProjection, readProjectOpenAiProviderConfig, withProjectOpenAiProviderConfigLock, writeProjectOpenAiProviderConfig, } from "./provider-config.js";
+function providerConfigSnapshot(options) {
+    const config = readProjectOpenAiProviderConfig(options.tuttiHome, options.projectId);
+    if (config.kind === "missing") {
+        return { kind: "unavailable", reason: "provider_not_configured" };
+    }
+    if (config.kind === "invalid") {
+        return { kind: "unavailable", reason: "provider_config_invalid" };
+    }
+    try {
+        const credential = readOpenAiApiKeyCredential(options.tuttiHome, options.projectId, config.config.credential_ref);
+        return { kind: "ready", config: config.config, apiKey: credential.secret };
+    }
+    catch {
+        return { kind: "unavailable", reason: "provider_credential_missing" };
+    }
+}
+function providerInput(config, apiKey) {
+    return {
+        apiKey,
+        ...(config.api_base_url === undefined ? {} : { apiBaseUrl: config.api_base_url }),
+        ...(config.organization_id === undefined ? {} : { organizationId: config.organization_id }),
+        ...(config.openai_project_id === undefined
+            ? {}
+            : { openAiProjectId: config.openai_project_id }),
+    };
+}
+export async function discoverProjectOpenAiModels(options) {
+    return await withProjectOpenAiProviderConfigLock(options, async () => {
+        const snapshot = providerConfigSnapshot(options);
+        if (snapshot.kind === "unavailable") {
+            return snapshot;
+        }
+        return await (options.discoverModels ?? discoverOpenAiModels)(providerInput(snapshot.config, snapshot.apiKey));
+    });
+}
+export async function updateProjectOpenAiDefaultModel(options) {
+    return await withProjectOpenAiProviderConfigLock(options, async () => {
+        const snapshot = providerConfigSnapshot(options);
+        if (snapshot.kind === "unavailable") {
+            return { kind: "provider_unavailable", reason: snapshot.reason };
+        }
+        if (snapshot.config.default_model !== options.expectedDefaultModel) {
+            return {
+                kind: "stale_default_model",
+                current_default_model: snapshot.config.default_model,
+            };
+        }
+        if (snapshot.config.default_model === options.defaultModel) {
+            return {
+                kind: "unchanged",
+                projection: createRedactedOpenAiProviderConfigProjection(snapshot.config),
+            };
+        }
+        const validator = options.validateCredential ??
+            ((input) => validateOpenAiCredential(input, options.now === undefined ? {} : { now: options.now }));
+        const validation = await validator({
+            ...providerInput(snapshot.config, snapshot.apiKey),
+            defaultModel: options.defaultModel,
+        });
+        if (validation.kind === "failed") {
+            return {
+                kind: "validation_failed",
+                reason: validation.reason,
+                retryable: validation.retryable,
+            };
+        }
+        const config = {
+            ...snapshot.config,
+            default_model: validation.default_model,
+            validated_at: validation.validated_at,
+        };
+        writeProjectOpenAiProviderConfig(options.tuttiHome, options.projectId, config);
+        return {
+            kind: "updated",
+            projection: createRedactedOpenAiProviderConfigProjection(config),
+        };
+    });
+}
+//# sourceMappingURL=provider-models.js.map

package/dist/providers/openai/provider-setup.d.ts

@@ -0,0 +1,31 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type OpenAiCredentialRef } from "./credential-store.js";
+import { type OpenAiCredentialValidationDiagnostic, type OpenAiCredentialValidationInput, type OpenAiCredentialValidationResult } from "./credential-validation.js";
+import { type OpenAiProviderConfig, type RedactedOpenAiProviderConfigProjection } from "./provider-config.js";
+export type ProjectOpenAiProviderSetupInput = {
+    apiKey: string;
+    apiBaseUrl?: string;
+    defaultModel?: string;
+};
+export type OpenAiProviderCredentialValidator = (input: OpenAiCredentialValidationInput) => Promise<OpenAiCredentialValidationResult>;
+export type ConfigureProjectOpenAiProviderOptions = ProjectOpenAiProviderSetupInput & {
+    tuttiHome: string;
+    projectId: ProjectId;
+    validateCredential?: OpenAiProviderCredentialValidator;
+    createCredentialRef?: () => OpenAiCredentialRef;
+    now?: () => Date;
+};
+export type ConfigureProjectOpenAiProviderResult = {
+    kind: "configured";
+    config: OpenAiProviderConfig;
+    projection: RedactedOpenAiProviderConfigProjection;
+} | {
+    kind: "validation_failed";
+    reason: Exclude<OpenAiCredentialValidationResult, {
+        kind: "ok";
+    }>["reason"] | "provider_auth_invalid";
+    retryable: boolean;
+    diagnostic?: OpenAiCredentialValidationDiagnostic;
+};
+export declare function configureProjectOpenAiProvider(options: ConfigureProjectOpenAiProviderOptions): Promise<ConfigureProjectOpenAiProviderResult>;
+//# sourceMappingURL=provider-setup.d.ts.map

package/dist/providers/openai/provider-setup.js

@@ -0,0 +1,91 @@
+import { createOpenAiCredentialRef, createRedactedOpenAiApiKeyLabel, isOpenAiApiKey, writeOpenAiApiKeyCredential, } from "./credential-store.js";
+import { validateOpenAiCredential, } from "./credential-validation.js";
+import { DEFAULT_OPENAI_MODEL, OPENAI_API_KEY_AUTH_KIND, OPENAI_PROVIDER } from "./model-config.js";
+import { createRedactedOpenAiProviderConfigProjection, withProjectOpenAiProviderConfigLock, writeProjectOpenAiProviderConfig, } from "./provider-config.js";
+function trimOptional(value) {
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed === "" ? undefined : trimmed;
+}
+function validateApiBaseUrl(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    try {
+        const url = new URL(value);
+        if (url.protocol === "http:" || url.protocol === "https:") {
+            return value;
+        }
+    }
+    catch {
+        // Fall through to the same validation result used for malformed URLs.
+    }
+    return undefined;
+}
+function validationInput(options) {
+    const input = {
+        apiKey: options.apiKey.trim(),
+        defaultModel: trimOptional(options.defaultModel) ?? DEFAULT_OPENAI_MODEL,
+    };
+    const apiBaseUrl = validateApiBaseUrl(trimOptional(options.apiBaseUrl));
+    if (apiBaseUrl !== undefined) {
+        input.apiBaseUrl = apiBaseUrl;
+    }
+    return input;
+}
+async function configureProjectOpenAiProviderUnlocked(options) {
+    const apiKey = options.apiKey.trim();
+    if (!isOpenAiApiKey(apiKey)) {
+        return {
+            kind: "validation_failed",
+            reason: "provider_auth_invalid",
+            retryable: false,
+        };
+    }
+    const apiBaseUrl = trimOptional(options.apiBaseUrl);
+    if (apiBaseUrl !== undefined && validateApiBaseUrl(apiBaseUrl) === undefined) {
+        return {
+            kind: "validation_failed",
+            reason: "provider_network_error",
+            retryable: false,
+        };
+    }
+    const validator = options.validateCredential ?? validateOpenAiCredential;
+    const validation = await validator(validationInput(options));
+    if (validation.kind === "failed") {
+        return {
+            kind: "validation_failed",
+            reason: validation.reason,
+            retryable: validation.retryable,
+            ...(validation.diagnostic === undefined ? {} : { diagnostic: validation.diagnostic }),
+        };
+    }
+    const credentialRef = (options.createCredentialRef ?? createOpenAiCredentialRef)();
+    writeOpenAiApiKeyCredential({
+        tuttiHome: options.tuttiHome,
+        projectId: options.projectId,
+        credentialRef,
+        apiKey,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    const config = {
+        provider: OPENAI_PROVIDER,
+        auth_kind: OPENAI_API_KEY_AUTH_KIND,
+        credential_ref: credentialRef,
+        redacted_key: createRedactedOpenAiApiKeyLabel(apiKey),
+        default_model: validation.default_model,
+        validated_at: validation.validated_at,
+    };
+    if (apiBaseUrl !== undefined) {
+        config.api_base_url = apiBaseUrl;
+    }
+    writeProjectOpenAiProviderConfig(options.tuttiHome, options.projectId, config);
+    return {
+        kind: "configured",
+        config,
+        projection: createRedactedOpenAiProviderConfigProjection(config),
+    };
+}
+export async function configureProjectOpenAiProvider(options) {
+    return await withProjectOpenAiProviderConfigLock(options, () => configureProjectOpenAiProviderUnlocked(options));
+}
+//# sourceMappingURL=provider-setup.js.map

package/dist/providers/openai/sdk-procedure-runner.d.ts

@@ -0,0 +1,70 @@
+import type { OpenAiCredentialAccess } from "./execution-access.js";
+import { type OpenAiCredentialValidationDiagnostic, type OpenAiCredentialValidationFailureReason } from "./credential-validation.js";
+import { type OpenAiTokenUsage } from "./token-usage.js";
+export type OpenAiJsonSchema = {
+    [key: string]: unknown;
+};
+export type OpenAiStructuredOutputClient = {
+    responses: {
+        create: (body: {
+            model: string;
+            input: string;
+            instructions?: string;
+            max_output_tokens: number;
+            store: false;
+            text: {
+                format: {
+                    type: "json_schema";
+                    name: string;
+                    schema: OpenAiJsonSchema;
+                    description?: string;
+                    strict: true;
+                };
+            };
+        }, options?: {
+            timeout?: number;
+            maxRetries?: number;
+        }) => Promise<unknown>;
+    };
+};
+export type OpenAiStructuredOutputClientInput = OpenAiCredentialAccess & {
+    apiBaseUrl?: string;
+    organizationId?: string;
+    openAiProjectId?: string;
+};
+export type OpenAiStructuredOutputFailureReason = OpenAiCredentialValidationFailureReason | "provider_invalid_response";
+export type OpenAiStructuredOutputInvalidResponseKind = "missing_output_text" | "empty_output_text" | "malformed_json" | "schema_invalid";
+export type OpenAiStructuredOutputErrorDetails = {
+    reason: OpenAiStructuredOutputFailureReason;
+    retryable: boolean;
+    invalid_response_kind?: OpenAiStructuredOutputInvalidResponseKind;
+    provider_diagnostic?: OpenAiCredentialValidationDiagnostic;
+};
+export type RunOpenAiStructuredOutputOptions<TOutput> = {
+    client?: OpenAiStructuredOutputClient;
+    model: string;
+    instructions: string;
+    input: string;
+    schemaName: string;
+    schemaDescription?: string;
+    schema: OpenAiJsonSchema;
+    maxOutputTokens?: number;
+    maxAttempts?: number;
+    timeoutMs?: number;
+    validate?: (value: unknown) => value is TOutput;
+};
+export type OpenAiStructuredOutputResult<TOutput> = {
+    output: TOutput;
+    raw_text: string;
+    usage?: OpenAiTokenUsage;
+};
+export declare class OpenAiStructuredOutputError extends Error {
+    readonly reason: OpenAiStructuredOutputFailureReason;
+    readonly retryable: boolean;
+    readonly invalidResponseKind?: OpenAiStructuredOutputInvalidResponseKind | undefined;
+    readonly details: OpenAiStructuredOutputErrorDetails;
+    constructor(reason: OpenAiStructuredOutputFailureReason, retryable: boolean, message: string, invalidResponseKind?: OpenAiStructuredOutputInvalidResponseKind | undefined, providerDiagnostic?: OpenAiCredentialValidationDiagnostic);
+}
+export declare function createOpenAiStructuredOutputClient(input: OpenAiStructuredOutputClientInput): OpenAiStructuredOutputClient;
+export declare function runOpenAiStructuredOutput<TOutput>(options: RunOpenAiStructuredOutputOptions<TOutput>): Promise<OpenAiStructuredOutputResult<TOutput>>;
+//# sourceMappingURL=sdk-procedure-runner.d.ts.map