@xfey/tutti 0.1.0

package/dist/providers/openai/credential-validation.js

@@ -0,0 +1,190 @@
+import OpenAI, { APIConnectionError, APIConnectionTimeoutError, APIError, AuthenticationError, NotFoundError, PermissionDeniedError, RateLimitError, } from "openai";
+import { DEFAULT_OPENAI_MODEL } from "./model-config.js";
+const VALIDATION_INPUT = "Tutti provider validation. Reply with the single word ok.";
+const VALIDATION_TIMEOUT_MS = 20_000;
+function createOpenAiValidationClient(input) {
+    const clientOptions = {
+        apiKey: input.apiKey,
+        maxRetries: 0,
+        timeout: VALIDATION_TIMEOUT_MS,
+    };
+    if (input.apiBaseUrl !== undefined) {
+        clientOptions.baseURL = input.apiBaseUrl;
+    }
+    if (input.organizationId !== undefined) {
+        clientOptions.organization = input.organizationId;
+    }
+    if (input.openAiProjectId !== undefined) {
+        clientOptions.project = input.openAiProjectId;
+    }
+    return new OpenAI(clientOptions);
+}
+function lowerErrorText(error) {
+    if (error instanceof Error) {
+        return error.message.toLowerCase();
+    }
+    return "";
+}
+function apiErrorCode(error) {
+    if (error instanceof APIError) {
+        const code = error.code;
+        if (typeof code === "string" || code === null || code === undefined) {
+            return code;
+        }
+        return undefined;
+    }
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (typeof error.code === "string" || error.code === null || error.code === undefined)) {
+        return error.code;
+    }
+    return undefined;
+}
+function apiErrorStatus(error) {
+    if (error instanceof APIError) {
+        const status = error.status;
+        return typeof status === "number" ? status : undefined;
+    }
+    if (typeof error === "object" &&
+        error !== null &&
+        "status" in error &&
+        typeof error.status === "number") {
+        return error.status;
+    }
+    return undefined;
+}
+function errorName(error) {
+    if (error instanceof Error && error.name.trim() !== "") {
+        return error.name;
+    }
+    if (typeof error === "object" &&
+        error !== null &&
+        "name" in error &&
+        typeof error.name === "string" &&
+        error.name.trim() !== "") {
+        return error.name;
+    }
+    return "UnknownError";
+}
+function retryableEvidence(input) {
+    const evidence = [];
+    if (input.retryable) {
+        evidence.push(`reason:${input.reason}`);
+    }
+    if (input.status !== undefined && input.status >= 500) {
+        evidence.push(`http_status:${input.status}`);
+    }
+    if (input.error instanceof APIConnectionTimeoutError) {
+        evidence.push("sdk:connection_timeout");
+    }
+    else if (input.error instanceof APIConnectionError) {
+        evidence.push("sdk:connection_error");
+    }
+    else if (input.error instanceof RateLimitError) {
+        evidence.push("sdk:rate_limit");
+    }
+    return evidence;
+}
+export function summarizeOpenAiCredentialValidationError(error, reason) {
+    const status = apiErrorStatus(error);
+    const code = apiErrorCode(error);
+    const retryable = isOpenAiCredentialValidationFailureRetryable(reason);
+    const diagnostic = {
+        error_name: errorName(error),
+        retryable_evidence: retryableEvidence({ reason, retryable, status, error }),
+    };
+    if (status !== undefined) {
+        diagnostic.http_status = status;
+    }
+    if (code !== undefined) {
+        diagnostic.provider_error_code = code;
+    }
+    return diagnostic;
+}
+function looksLikeQuotaOrBillingFailure(error) {
+    const code = apiErrorCode(error);
+    if (code === "insufficient_quota" ||
+        code === "billing_hard_limit_reached" ||
+        code === "billing_not_active") {
+        return true;
+    }
+    const message = lowerErrorText(error);
+    return (message.includes("quota") ||
+        message.includes("billing") ||
+        message.includes("credit") ||
+        message.includes("payment"));
+}
+function looksLikeModelUnavailable(error) {
+    const status = apiErrorStatus(error);
+    if (status === 404 || error instanceof NotFoundError) {
+        return true;
+    }
+    const code = apiErrorCode(error);
+    if (code === "model_not_found" || code === "model_not_available") {
+        return true;
+    }
+    const message = lowerErrorText(error);
+    return (message.includes("model") &&
+        (message.includes("not found") ||
+            message.includes("does not exist") ||
+            message.includes("unavailable") ||
+            message.includes("not available")));
+}
+export function classifyOpenAiCredentialValidationError(error) {
+    const status = apiErrorStatus(error);
+    if (error instanceof AuthenticationError || status === 401) {
+        return "provider_auth_invalid";
+    }
+    if (looksLikeModelUnavailable(error)) {
+        return "provider_model_unavailable";
+    }
+    if (looksLikeQuotaOrBillingFailure(error)) {
+        return "provider_quota_or_billing_required";
+    }
+    if (error instanceof PermissionDeniedError || status === 403) {
+        return "provider_quota_or_billing_required";
+    }
+    if (error instanceof RateLimitError || status === 429) {
+        return "provider_rate_limited";
+    }
+    if (error instanceof APIConnectionError ||
+        error instanceof APIConnectionTimeoutError ||
+        status === undefined ||
+        status >= 500) {
+        return "provider_network_error";
+    }
+    return "provider_network_error";
+}
+export function isOpenAiCredentialValidationFailureRetryable(reason) {
+    return reason === "provider_rate_limited" || reason === "provider_network_error";
+}
+export async function validateOpenAiCredential(input, options = {}) {
+    const model = input.defaultModel ?? DEFAULT_OPENAI_MODEL;
+    const client = options.client ?? createOpenAiValidationClient(input);
+    try {
+        await client.responses.create({
+            model,
+            input: VALIDATION_INPUT,
+            max_output_tokens: 16,
+        }, {
+            timeout: VALIDATION_TIMEOUT_MS,
+            maxRetries: 0,
+        });
+        return {
+            kind: "ok",
+            default_model: model,
+            validated_at: (options.now ?? (() => new Date()))().toISOString(),
+        };
+    }
+    catch (error) {
+        const reason = classifyOpenAiCredentialValidationError(error);
+        return {
+            kind: "failed",
+            reason,
+            retryable: isOpenAiCredentialValidationFailureRetryable(reason),
+            diagnostic: summarizeOpenAiCredentialValidationError(error, reason),
+        };
+    }
+}
+//# sourceMappingURL=credential-validation.js.map

package/dist/providers/openai/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./codex-app-server.js";
+export * from "./app-server/json-rpc.js";
+export * from "./app-server/read-only-procedure.js";
+export * from "./app-server/skills.js";
+export * from "./app-server/smoke.js";
+export * from "./credential-store.js";
+export * from "./credential-validation.js";
+export * from "./model-config.js";
+export * from "./provider-config.js";
+export * from "./provider-setup.js";
+export * from "./sdk-procedure-runner.js";
+export * from "./token-usage.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/openai/index.js

@@ -0,0 +1,13 @@
+export * from "./codex-app-server.js";
+export * from "./app-server/json-rpc.js";
+export * from "./app-server/read-only-procedure.js";
+export * from "./app-server/skills.js";
+export * from "./app-server/smoke.js";
+export * from "./credential-store.js";
+export * from "./credential-validation.js";
+export * from "./model-config.js";
+export * from "./provider-config.js";
+export * from "./provider-setup.js";
+export * from "./sdk-procedure-runner.js";
+export * from "./token-usage.js";
+//# sourceMappingURL=index.js.map

package/dist/providers/openai/machine-local-files.d.ts

@@ -0,0 +1,19 @@
+export type JsonFileReadResult = {
+    kind: "missing";
+} | {
+    kind: "parse_failed";
+} | {
+    kind: "loaded";
+    value: unknown;
+};
+export declare function ensurePrivateDirectory(directoryPath: string): void;
+export declare function writePrivateJsonFile(filePath: string, value: unknown): void;
+export declare function writePrivateTextFile(filePath: string, value: string): void;
+export declare function readJsonFile(filePath: string): JsonFileReadResult;
+export declare function readTextFile(filePath: string): {
+    kind: "missing";
+} | {
+    kind: "loaded";
+    value: string;
+};
+//# sourceMappingURL=machine-local-files.d.ts.map

package/dist/providers/openai/machine-local-files.js

@@ -0,0 +1,55 @@
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+function isErrnoException(error) {
+    return error instanceof Error && "code" in error;
+}
+export function ensurePrivateDirectory(directoryPath) {
+    mkdirSync(directoryPath, { recursive: true, mode: 0o700 });
+    chmodSync(directoryPath, 0o700);
+}
+export function writePrivateJsonFile(filePath, value) {
+    ensurePrivateDirectory(dirname(filePath));
+    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    chmodSync(filePath, 0o600);
+}
+export function writePrivateTextFile(filePath, value) {
+    ensurePrivateDirectory(dirname(filePath));
+    writeFileSync(filePath, value, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    chmodSync(filePath, 0o600);
+}
+export function readJsonFile(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return { kind: "missing" };
+        }
+        throw error;
+    }
+    try {
+        return { kind: "loaded", value: JSON.parse(raw) };
+    }
+    catch {
+        return { kind: "parse_failed" };
+    }
+}
+export function readTextFile(filePath) {
+    try {
+        return { kind: "loaded", value: readFileSync(filePath, "utf8") };
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return { kind: "missing" };
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=machine-local-files.js.map

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

@@ -0,0 +1,4 @@
+export declare const OPENAI_PROVIDER: "openai";
+export declare const OPENAI_API_KEY_AUTH_KIND: "api_key";
+export declare const DEFAULT_OPENAI_MODEL: "gpt-5.5";
+//# sourceMappingURL=model-config.d.ts.map

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

@@ -0,0 +1,4 @@
+export const OPENAI_PROVIDER = "openai";
+export const OPENAI_API_KEY_AUTH_KIND = "api_key";
+export const DEFAULT_OPENAI_MODEL = "gpt-5.5";
+//# sourceMappingURL=model-config.js.map

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

@@ -0,0 +1,6 @@
+export declare class OpenAiProviderConfigError extends Error {
+    readonly code: "json_parse_failed" | "toml_parse_failed" | "not_object" | "unknown_field" | "invalid_provider" | "invalid_auth_kind" | "credential_ref_missing" | "invalid_field";
+    readonly field?: string | undefined;
+    constructor(code: "json_parse_failed" | "toml_parse_failed" | "not_object" | "unknown_field" | "invalid_provider" | "invalid_auth_kind" | "credential_ref_missing" | "invalid_field", field?: string | undefined);
+}
+//# sourceMappingURL=provider-config-errors.d.ts.map

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

@@ -0,0 +1,13 @@
+export class OpenAiProviderConfigError extends Error {
+    code;
+    field;
+    constructor(code, field) {
+        super(field === undefined
+            ? `OpenAI provider config error: ${code}`
+            : `OpenAI provider config error: ${code} at ${field}`);
+        this.code = code;
+        this.field = field;
+        this.name = "OpenAiProviderConfigError";
+    }
+}
+//# sourceMappingURL=provider-config-errors.js.map

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

@@ -0,0 +1,3 @@
+import type { OpenAiProviderConfig } from "./provider-config.js";
+export declare function parseOpenAiProviderConfig(value: unknown): OpenAiProviderConfig;
+//# sourceMappingURL=provider-config-shape.d.ts.map

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

@@ -0,0 +1,108 @@
+import { isOpenAiCredentialRef, } from "./credential-store.js";
+import { DEFAULT_OPENAI_MODEL, OPENAI_API_KEY_AUTH_KIND, OPENAI_PROVIDER } from "./model-config.js";
+import { OpenAiProviderConfigError } from "./provider-config-errors.js";
+const PROJECT_CONFIG_KEYS = new Set([
+    "provider",
+    "auth_kind",
+    "credential_ref",
+    "redacted_key",
+    "validated_at",
+    "default_model",
+    "api_base_url",
+    "organization_id",
+    "openai_project_id",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isIsoDateString(value) {
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+}
+function readOptionalString(value, field) {
+    const nested = value[field];
+    if (nested === undefined) {
+        return undefined;
+    }
+    if (!isNonEmptyString(nested)) {
+        throw new OpenAiProviderConfigError("invalid_field", field);
+    }
+    return nested;
+}
+function validateOptionalUrl(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new OpenAiProviderConfigError("invalid_field", field);
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+        throw new OpenAiProviderConfigError("invalid_field", field);
+    }
+    return value;
+}
+function assertAllowedKeys(value, allowedKeys) {
+    for (const key of Object.keys(value)) {
+        if (!allowedKeys.has(key)) {
+            throw new OpenAiProviderConfigError("unknown_field", key);
+        }
+    }
+}
+function readRequiredTimestamp(value, field) {
+    const nested = value[field];
+    if (!isNonEmptyString(nested) || !isIsoDateString(nested)) {
+        throw new OpenAiProviderConfigError("invalid_field", field);
+    }
+    return nested;
+}
+function readRequiredCredentialRef(value) {
+    const credentialRef = value.credential_ref;
+    if (!isNonEmptyString(credentialRef) || !isOpenAiCredentialRef(credentialRef)) {
+        throw new OpenAiProviderConfigError("credential_ref_missing", "credential_ref");
+    }
+    return credentialRef;
+}
+export function parseOpenAiProviderConfig(value) {
+    if (!isRecord(value)) {
+        throw new OpenAiProviderConfigError("not_object");
+    }
+    assertAllowedKeys(value, PROJECT_CONFIG_KEYS);
+    if (value.provider !== OPENAI_PROVIDER) {
+        throw new OpenAiProviderConfigError("invalid_provider", "provider");
+    }
+    if (value.auth_kind !== OPENAI_API_KEY_AUTH_KIND) {
+        throw new OpenAiProviderConfigError("invalid_auth_kind", "auth_kind");
+    }
+    const config = {
+        provider: OPENAI_PROVIDER,
+        auth_kind: OPENAI_API_KEY_AUTH_KIND,
+        credential_ref: readRequiredCredentialRef(value),
+        redacted_key: readOptionalString(value, "redacted_key") ?? "",
+        validated_at: readRequiredTimestamp(value, "validated_at"),
+        default_model: readOptionalString(value, "default_model") ?? DEFAULT_OPENAI_MODEL,
+    };
+    if (config.redacted_key === "") {
+        throw new OpenAiProviderConfigError("invalid_field", "redacted_key");
+    }
+    const apiBaseUrl = validateOptionalUrl(readOptionalString(value, "api_base_url"), "api_base_url");
+    if (apiBaseUrl !== undefined) {
+        config.api_base_url = apiBaseUrl;
+    }
+    const organizationId = readOptionalString(value, "organization_id");
+    if (organizationId !== undefined) {
+        config.organization_id = organizationId;
+    }
+    const openAiProjectId = readOptionalString(value, "openai_project_id");
+    if (openAiProjectId !== undefined) {
+        config.openai_project_id = openAiProjectId;
+    }
+    return config;
+}
+//# sourceMappingURL=provider-config-shape.js.map

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

@@ -0,0 +1,13 @@
+import type { OpenAiProviderConfig } from "./provider-config.js";
+type TomlScalar = string | number;
+type ParsedTomlDocument = {
+    root: Record<string, TomlScalar>;
+    sections: Record<string, Record<string, TomlScalar>>;
+};
+export declare function parseTuttiConfigToml(raw: string): ParsedTomlDocument;
+export declare function parseTomlOpenAiSection(options: {
+    document: ParsedTomlDocument;
+}): Record<string, unknown>;
+export declare function formatProjectOpenAiProviderConfig(config: OpenAiProviderConfig): string;
+export {};
+//# sourceMappingURL=provider-config-toml.d.ts.map

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,73 @@
+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 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