@inkdropapp/ai 0.1.4 → 0.1.6

package/README.md

@@ -12,6 +12,7 @@ in the Inkdrop Electron main process.
 - **URL-keyed credential storage** via `@napi-rs/keyring`. Two endpoints to the same provider get separate keyring entries automatically.
 - **Single streaming event type** — every provider's stream is reduced to a `StreamEvent` discriminated union.
 - **Retry-aware error type** — `RateLimitExceeded` / `ServerOverloaded` carry `retryAfter` (seconds) parsed from the response header.
+- **Per-call observability** — opt-in `apiCallListener` receives a structured event per upstream HTTP request (URL, sanitized headers, body, status, duration). Designed to back a user-facing API invocation log.
 - **No tools, no agents, no UI, no persistence in v0.1** — see [Out of scope](#out-of-scope-deferred).
 
 ---
@@ -100,9 +101,9 @@ Inkdrop's AI features map onto two slots:
 
 A slot resolves to `(provider, model)` via:
 
-1. Explicit binding from `settings.slots[slot]`, if both the provider id and model id resolve. *(Advanced — pin a specific model per slot or mix providers across slots.)*
+1. Explicit binding from `settings.slots[slot]`, if both the provider id and model id resolve. _(Advanced — pin a specific model per slot or mix providers across slots.)_
 2. For `'fast'` only: fall back to `settings.slots.default` if that resolves.
-3. Preferred provider from `settings.providerId`, if configured — takes its `defaultModel()` (for `default`) or `defaultFastModel()` (for `fast`). *(The simple UI knob — one provider dropdown drives every slot.)*
+3. Preferred provider from `settings.providerId`, if configured — takes its `defaultModel()` (for `default`) or `defaultFastModel()` (for `fast`). _(The simple UI knob — one provider dropdown drives every slot.)_
 4. First **authenticated** registered provider in alphabetical id order, taking its `defaultModel()` / `defaultFastModel()`.
 5. `undefined` if no provider can satisfy the slot.
 
@@ -232,6 +233,61 @@ Three contracts you can rely on:
 The library is currently text-only — `tool-call` / `tool-result` variants are
 typed for forward compat but never produced.
 
+### API call logging
+
+Pass `apiCallListener` to `AIRegistry` to receive one event per upstream HTTP
+request. Useful for backing a user-facing "API invocation log" view, or for
+ad-hoc debugging in development.
+
+```ts
+import { AIRegistry, type AIModelApiCallEvent } from '@inkdropapp/ai'
+
+const registry = new AIRegistry({
+  settings,
+  apiCallListener: (event: AIModelApiCallEvent) => {
+    const status = event.status ?? `failed: ${event.failure}`
+    console.log(
+      `[${event.providerId}] ${event.request.method} ${event.request.url}`,
+      `→ ${status} (${event.durationMs}ms)`
+    )
+    if (event.errorBody) console.error(event.errorBody)
+  }
+})
+```
+
+The listener fires exactly once per HTTP request, after response headers
+arrive (or after the fetch itself fails). For streaming responses, `durationMs`
+is time-to-first-byte — the response stream is _not_ tee'd. Only error bodies
+(`status >= 400`) are captured. API keys are redacted from `request.headers`
+before the event is emitted.
+
+The hook is best-effort logging only: exceptions thrown from the listener are
+swallowed so they cannot interrupt the request path.
+
+Event shape:
+
+```ts
+type AIModelApiCallEvent = {
+  providerId: string
+  startedAt: number // epoch ms
+  durationMs: number // headers received (TTFB for streams)
+  request: {
+    method: string
+    url: string
+    headers: Record<string, string> // authorization / x-api-key redacted
+    body: unknown // parsed JSON when possible, else string
+  }
+  status: number | undefined // undefined when fetch itself threw
+  errorBody?: string // populated only when status >= 400
+  failure?: string // populated only when fetch itself threw
+}
+```
+
+**Gap to be aware of:** mid-stream errors (e.g. Anthropic's `event: error`
+frames inside a `200 OK` SSE body) are surfaced via the `StreamEvent` union
+(`{ kind: 'error' }`), _not_ through the API call listener. The listener only
+sees what the HTTP layer sees.
+
 ### Errors
 
 `AIError` is the base class. Variants:
@@ -274,8 +330,9 @@ hosts that want to predict the name (e.g. for an onboarding hint).
 ```ts
 new AIRegistry({
   settings: AISettings,
-  catalog?: AIModelCatalog,   // server-distributed model lists; see "Model catalogues"
-  keyStore?: KeyStore
+  catalog?: AIModelCatalog,           // server-distributed model lists; see "Model catalogues"
+  keyStore?: KeyStore,
+  apiCallListener?: AIModelApiCallListener  // wire-level invocation log; see "API call logging"
 })
 
 registry.listProviders(): AIProvider[]
@@ -503,9 +560,11 @@ for (const { provider, model } of registry.listAllModels()) {
 
 ```sh
 npm install
-npm test          # runs all 82 tests against the real system keyring
+npm test                  # runs the full test suite against the real system keyring
 npm run lint
-npm run gen       # emits .d.ts files into types/
+npm run build             # regenerates standalone validators, then emits .d.ts into types/
+npm run build:validators  # regenerates standalone validators only (run after a schema change)
+npm run build:types       # emits .d.ts files into types/
 ```
 
 Tests use a unique per-run keyring service name (`inkdrop.ai.test.<hex>`) so they

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkdropapp/ai",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "AI integration common module",
   "type": "module",
   "main": "src/index.ts",
@@ -11,24 +11,27 @@
       "default": "./src/index.ts"
     },
     "./constants": {
-      "types": "./types/provider-constants.d.ts",
-      "default": "./src/provider-constants.ts"
+      "types": "./types/constants.d.ts",
+      "default": "./src/constants.ts"
     }
   },
-  "scripts": {
-    "lint": "eslint src __tests__",
-    "test": "node --experimental-vm-modules --no-warnings=ExperimentalWarning node_modules/jest/bin/jest.js --config jest.config.cjs --runInBand",
-    "build": "tsc --declaration --emitDeclarationOnly",
-    "format": "prettier --write .",
-    "prepublishOnly": "npm-run-all lint test build"
-  },
   "keywords": [
     "ai",
     "inkdrop"
   ],
-  "author": "Takuya Matsuyama <t@inkdrop.app>",
+  "author": {
+    "name": "Takuya Matsuyama",
+    "email": "t@inkdrop.app"
+  },
+  "homepage": "https://github.com/inkdropapp/ai#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/inkdropapp/ai.git"
+  },
+  "bugs": {
+    "url": "https://github.com/inkdropapp/ai/issues"
+  },
   "license": "UNLICENSED",
-  "packageManager": "pnpm@11.1.1",
   "dependencies": {
     "@ai-sdk/anthropic": "4.0.0-beta.42",
     "@ai-sdk/openai-compatible": "3.0.0-beta.36",
@@ -36,6 +39,7 @@
     "@inkdropapp/ai-catalog": "^0.1.0",
     "@napi-rs/keyring": "^1.2.0",
     "ai": "7.0.0-beta.116",
+    "ajv": "^8.20.0",
     "npm-run-all2": "^8.0.4"
   },
   "devDependencies": {
@@ -52,5 +56,13 @@
   "files": [
     "src",
     "types"
-  ]
-}
+  ],
+  "scripts": {
+    "lint": "eslint src __tests__",
+    "test": "node --experimental-vm-modules --no-warnings=ExperimentalWarning node_modules/jest/bin/jest.js --config jest.config.cjs --runInBand",
+    "build:validators": "node scripts/build-validators.mjs",
+    "build:types": "tsc --declaration --emitDeclarationOnly",
+    "build": "npm-run-all build:validators build:types",
+    "format": "prettier --write ."
+  }
+}

package/src/constants.ts

@@ -0,0 +1,43 @@
+/**
+ * Pure-data constants for settings UIs.
+ *
+ * This module has no class or native-module imports, so it's safe to load in
+ * an Electron renderer process — unlike the main package entrypoint, which
+ * transitively pulls in `@napi-rs/keyring`.
+ *
+ * Consume via the `@inkdropapp/ai/constants` subpath:
+ *
+ *   import {
+ *     ANTHROPIC_PROVIDER_ID,
+ *     ANTHROPIC_PROVIDER_NAME,
+ *     ANTHROPIC_ENV_VAR,
+ *     ANTHROPIC_DEFAULT_BASE_URL,
+ *     OPENAI_COMPATIBLE_PROVIDER_ID,
+ *     OPENAI_COMPATIBLE_PROVIDER_NAME,
+ *     deriveEnvVarName,
+ *     SLOT_DEFAULT,
+ *     SLOT_FAST
+ *   } from '@inkdropapp/ai/constants'
+ */
+
+import type { SlotName } from './settings.js'
+
+export {
+  ANTHROPIC_PROVIDER_ID,
+  ANTHROPIC_PROVIDER_NAME,
+  ANTHROPIC_ENV_VAR,
+  ANTHROPIC_DEFAULT_BASE_URL
+} from './providers/anthropic/constants.js'
+export {
+  OPENAI_COMPATIBLE_PROVIDER_ID,
+  OPENAI_COMPATIBLE_PROVIDER_NAME,
+  deriveEnvVarName
+} from './providers/openai-compatible/constants.js'
+
+/**
+ * String literals for the two task slots exposed by {@link SlotName}.
+ * `satisfies SlotName` preserves the narrow literal type while verifying at
+ * compile time that the value is a valid `SlotName`.
+ */
+export const SLOT_DEFAULT = 'default' satisfies SlotName
+export const SLOT_FAST = 'fast' satisfies SlotName

package/src/events.ts

@@ -0,0 +1,105 @@
+import type { AIError } from './errors.js'
+
+// ─── In-stream completion events ─────────────────────────────────────────────
+//
+// Fire while a single `streamCompletion` call is in flight. Provider-agnostic:
+// every concrete provider's stream is reduced to `StreamEvent` so consumers
+// never branch on provider id.
+
+/**
+ * Why a completion stream stopped producing output.
+ *
+ * Mirrors the AI SDK's `FinishReason`. Unknown / provider-specific values are
+ * normalised to `'other'` rather than silently passed through.
+ */
+export type FinishReason =
+  | 'stop'
+  | 'length'
+  | 'content-filter'
+  | 'tool-calls'
+  | 'error'
+  | 'other'
+
+/**
+ * Token usage for a single completion. Every field is optional because
+ * not every provider reports every counter.
+ */
+export type Usage = {
+  /** Tokens consumed from the prompt. */
+  inputTokens?: number
+  /** Tokens generated in the response. */
+  outputTokens?: number
+  /** `inputTokens + outputTokens` as reported by the provider. */
+  totalTokens?: number
+  /** Of `inputTokens`, how many were a cache hit (Anthropic prompt-cache reads). */
+  cacheReadInputTokens?: number
+  /** Of `inputTokens`, how many were written to the prompt cache for future reads. */
+  cacheCreationInputTokens?: number
+  /** Subset of `outputTokens` spent on reasoning / thinking content. */
+  reasoningTokens?: number
+}
+
+/**
+ * Provider-agnostic streaming events. Every concrete provider's stream is
+ * reduced to this discriminated union so consumers never branch on provider id.
+ *
+ * Errors arrive as `{ kind: 'error', ... }` events, not as thrown exceptions —
+ * this lets the host pump events across an Electron IPC boundary one at a time
+ * without needing try/catch around the iterator.
+ *
+ * `tool-call` and `tool-result` are typed but never produced in the current
+ * version (one-shot text completions only). They're reserved for forward compat.
+ */
+export type StreamEvent =
+  | { kind: 'text-delta'; delta: string }
+  | { kind: 'tool-call'; id: string; name: string; input: unknown }
+  | { kind: 'tool-result'; id: string; name: string; result: unknown }
+  | { kind: 'usage-update'; usage: Usage }
+  | { kind: 'finish'; finishReason: FinishReason; usage: Usage }
+  | { kind: 'error'; error: AIError }
+
+// ─── HTTP-level invocation events ────────────────────────────────────────────
+//
+// Fire once per upstream HTTP request, independent of the in-stream
+// `StreamEvent` pipeline. Threaded into providers via
+// `AIRegistryOptions.apiCallListener`.
+
+/**
+ * Wire-level record of one HTTP request the library made to an upstream
+ * provider API. Emitted via {@link AIRegistryOptions.apiCallListener} so the host
+ * can persist or surface an invocation log to end users.
+ *
+ * The listener is invoked exactly once per HTTP request — after the response
+ * headers arrive (or after the fetch itself fails). Streaming response bodies
+ * are *not* tee'd; only error bodies (HTTP status >= 400) are captured.
+ *
+ * API keys are redacted from `request.headers` before the event is emitted.
+ */
+export type AIModelApiCallEvent = {
+  /** Provider id that owns the SDK client which made the call. */
+  providerId: string
+  /** Epoch ms at which the fetch was issued. */
+  startedAt: number
+  /**
+   * Wall-clock time from fetch start to response headers (or to the fetch
+   * promise settling on failure). For streaming responses this is
+   * time-to-first-byte, not total stream duration.
+   */
+  durationMs: number
+  request: {
+    method: string
+    url: string
+    /** Outgoing headers; `authorization` / `x-api-key` / `anthropic-api-key` are redacted. */
+    headers: Record<string, string>
+    /** Parsed JSON when the body was a JSON string; the raw string otherwise. */
+    body: unknown
+  }
+  /** HTTP status, or `undefined` if the fetch itself failed before a response. */
+  status: number | undefined
+  /** Response body — populated only when `status >= 400`. */
+  errorBody?: string
+  /** Failure reason — populated only when fetch itself threw (network error, abort, …). */
+  failure?: string
+}
+
+export type AIModelApiCallListener = (event: AIModelApiCallEvent) => void

package/src/index.ts

@@ -1,5 +1,16 @@
-export type { AIProvider, AIModel, CompletionRequest } from './provider.js'
-export type { StreamEvent, Usage, FinishReason } from './stream-events.js'
+export type {
+  AIProvider,
+  AIModel,
+  AIModelOptions,
+  CompletionRequest
+} from './provider.js'
+export type {
+  StreamEvent,
+  Usage,
+  FinishReason,
+  AIModelApiCallEvent,
+  AIModelApiCallListener
+} from './events.js'
 export type {
   AISettings,
   SlotName,
@@ -43,10 +54,12 @@ export {
   ANTHROPIC_DEFAULT_BASE_URL,
   OPENAI_COMPATIBLE_PROVIDER_ID,
   OPENAI_COMPATIBLE_PROVIDER_NAME,
-  deriveEnvVarName
-} from './provider-constants.js'
-export { AnthropicProvider } from './providers/anthropic.js'
-export { OpenAICompatibleProvider } from './providers/openai-compatible.js'
+  deriveEnvVarName,
+  SLOT_DEFAULT,
+  SLOT_FAST
+} from './constants.js'
+export { AnthropicProvider } from './providers/anthropic/provider.js'
+export { OpenAICompatibleProvider } from './providers/openai-compatible/provider.js'
 export {
   AIRegistry,
   type AIRegistryOptions,

package/src/provider.ts

@@ -3,7 +3,19 @@ import type {
   ModelCapabilities
 } from '@inkdropapp/ai-catalog'
 import type { ModelMessage } from 'ai'
-import type { StreamEvent } from './stream-events.js'
+import type { AIModelApiCallListener, StreamEvent } from './events.js'
+
+/**
+ * Provider-construction options that apply to every model the provider hosts.
+ * Threaded by `AIRegistry` into each provider's constructor.
+ */
+export type AIModelOptions = {
+  /**
+   * Invoked once per upstream HTTP request made by any model on this provider.
+   * See {@link AIModelApiCallListener}.
+   */
+  apiCallListener?: AIModelApiCallListener
+}
 
 /**
  * Inputs for a single one-shot streaming completion.

package/src/providers/anthropic/constants.ts

@@ -0,0 +1,4 @@
+export const ANTHROPIC_PROVIDER_ID = 'anthropic'
+export const ANTHROPIC_PROVIDER_NAME = 'Anthropic'
+export const ANTHROPIC_ENV_VAR = 'ANTHROPIC_API_KEY'
+export const ANTHROPIC_DEFAULT_BASE_URL = 'https://api.anthropic.com/v1'

package/src/providers/{anthropic.ts → anthropic/provider.ts}

@@ -14,22 +14,28 @@ import {
   type ModelCapabilities
 } from '@inkdropapp/ai-catalog'
 import { streamText } from 'ai'
-import { NoApiKey } from '../errors.js'
-import type { KeyStore } from '../key-store.js'
-import { mapAiSdkError } from '../internal/map-ai-sdk-error.js'
-import { mapAiSdkStream } from '../internal/map-ai-sdk-stream.js'
+import { NoApiKey } from '../../errors.js'
+import type { AIModelApiCallListener, StreamEvent } from '../../events.js'
+import type { KeyStore } from '../../key-store.js'
+import type {
+  AIModel,
+  AIModelOptions,
+  AIProvider,
+  CompletionRequest
+} from '../../provider.js'
+import type {
+  AnthropicModelConfig,
+  AnthropicProviderConfig
+} from '../../settings.js'
+import { createLoggingFetch } from '../../utils/logging-fetch.js'
+import { mapAiSdkError } from '../../utils/map-ai-sdk-error.js'
+import { mapAiSdkStream } from '../../utils/map-ai-sdk-stream.js'
 import {
   ANTHROPIC_DEFAULT_BASE_URL,
   ANTHROPIC_ENV_VAR,
   ANTHROPIC_PROVIDER_ID,
   ANTHROPIC_PROVIDER_NAME
-} from '../provider-constants.js'
-import type { AIModel, AIProvider, CompletionRequest } from '../provider.js'
-import type {
-  AnthropicModelConfig,
-  AnthropicProviderConfig
-} from '../settings.js'
-import type { StreamEvent } from '../stream-events.js'
+} from './constants.js'
 
 /**
  * The Anthropic (Claude) provider.
@@ -55,6 +61,7 @@ export class AnthropicProvider implements AIProvider {
   private readonly modelsById: Map<string, AnthropicAIModel>
   private readonly defaultId: string
   private readonly defaultFastId: string
+  private readonly apiCallListener: AIModelApiCallListener | undefined
 
   private sdkClient: SdkAnthropicProvider | undefined
   private sdkClientApiKey: string | undefined
@@ -62,10 +69,12 @@ export class AnthropicProvider implements AIProvider {
   constructor(
     keyStore: KeyStore,
     config: AnthropicProviderConfig = {},
-    catalog?: AnthropicCatalog
+    catalog?: AnthropicCatalog,
+    options: AIModelOptions = {}
   ) {
     this.keyStore = keyStore
     this.baseURL = config.baseURL ?? ANTHROPIC_DEFAULT_BASE_URL
+    this.apiCallListener = options.apiCallListener
 
     const baseModels = catalog?.models ?? ANTHROPIC_MODELS
     this.defaultId = catalog?.defaultModelId ?? ANTHROPIC_DEFAULT_MODEL_ID
@@ -122,7 +131,13 @@ export class AnthropicProvider implements AIProvider {
       throw new NoApiKey(this.id, this.envVarName)
     }
     if (this.sdkClient && this.sdkClientApiKey === apiKey) return this.sdkClient
-    this.sdkClient = createAnthropic({ apiKey, baseURL: this.baseURL })
+    this.sdkClient = createAnthropic({
+      apiKey,
+      baseURL: this.baseURL,
+      fetch: this.apiCallListener
+        ? createLoggingFetch(this.id, this.apiCallListener)
+        : undefined
+    })
     this.sdkClientApiKey = apiKey
     return this.sdkClient
   }

package/src/{provider-constants.ts → providers/openai-compatible/constants.ts}

@@ -1,28 +1,3 @@
-/**
- * Pure-data provider metadata for settings UIs.
- *
- * This module has no class or native-module imports, so it's safe to load in
- * an Electron renderer process — unlike the main package entrypoint, which
- * transitively pulls in `@napi-rs/keyring`.
- *
- * Consume via the `@inkdropapp/ai/constants` subpath:
- *
- *   import {
- *     ANTHROPIC_PROVIDER_ID,
- *     ANTHROPIC_PROVIDER_NAME,
- *     ANTHROPIC_ENV_VAR,
- *     ANTHROPIC_DEFAULT_BASE_URL,
- *     OPENAI_COMPATIBLE_PROVIDER_ID,
- *     OPENAI_COMPATIBLE_PROVIDER_NAME,
- *     deriveEnvVarName
- *   } from '@inkdropapp/ai/constants'
- */
-
-export const ANTHROPIC_PROVIDER_ID = 'anthropic'
-export const ANTHROPIC_PROVIDER_NAME = 'Anthropic'
-export const ANTHROPIC_ENV_VAR = 'ANTHROPIC_API_KEY'
-export const ANTHROPIC_DEFAULT_BASE_URL = 'https://api.anthropic.com'
-
 /**
  * The `AISettings.providers` key for OpenAI-compatible entries. Use this to
  * tag a settings-UI row as "an OpenAI-compatible provider" (vs. the built-in

package/src/providers/{openai-compatible.ts → openai-compatible/provider.ts}

@@ -7,17 +7,24 @@ import type {
   ModelCapabilities
 } from '@inkdropapp/ai-catalog'
 import { streamText } from 'ai'
-import { NoApiKey } from '../errors.js'
-import type { KeyStore } from '../key-store.js'
-import { mapAiSdkError } from '../internal/map-ai-sdk-error.js'
-import { mapAiSdkStream } from '../internal/map-ai-sdk-stream.js'
-import { deriveEnvVarName } from '../provider-constants.js'
-import type { AIModel, AIProvider, CompletionRequest } from '../provider.js'
+import { NoApiKey } from '../../errors.js'
+import type { AIModelApiCallListener, StreamEvent } from '../../events.js'
+import type { KeyStore } from '../../key-store.js'
+import type {
+  AIModel,
+  AIModelOptions,
+  AIProvider,
+  CompletionRequest
+} from '../../provider.js'
 import type {
   OpenAICompatibleModelConfig,
   OpenAICompatibleProviderConfig
-} from '../settings.js'
-import type { StreamEvent } from '../stream-events.js'
+} from '../../settings.js'
+import { createLoggingFetch } from '../../utils/logging-fetch.js'
+import { mapAiSdkError } from '../../utils/map-ai-sdk-error.js'
+import { mapAiSdkStream } from '../../utils/map-ai-sdk-stream.js'
+import { deriveEnvVarName } from './constants.js'
+import { validateOpenAICompatibleProviderConfig } from './validator.js'
 
 const DEFAULT_CAPABILITIES: ModelCapabilities = {
   supportsTools: true,
@@ -60,13 +67,20 @@ export class OpenAICompatibleProvider implements AIProvider {
   private readonly config: OpenAICompatibleProviderConfig
   private readonly keyStore: KeyStore
   private readonly modelsById: Map<string, OpenAICompatibleAIModel>
+  private readonly apiCallListener: AIModelApiCallListener | undefined
 
   private sdkClient: SdkOpenAICompatibleProvider | undefined
   private sdkClientApiKey: string | undefined
 
-  constructor(keyStore: KeyStore, config: OpenAICompatibleProviderConfig) {
+  constructor(
+    keyStore: KeyStore,
+    config: OpenAICompatibleProviderConfig,
+    options: AIModelOptions = {}
+  ) {
+    validateOpenAICompatibleProviderConfig(config)
     this.config = config
     this.keyStore = keyStore
+    this.apiCallListener = options.apiCallListener
     this.id = config.id
     this.name = config.displayName ?? config.id
     this.baseURL = config.baseURL
@@ -128,7 +142,10 @@ export class OpenAICompatibleProvider implements AIProvider {
     this.sdkClient = createOpenAICompatible({
       name: this.id,
       baseURL: this.baseURL,
-      apiKey: apiKey ?? undefined
+      apiKey: apiKey ?? undefined,
+      fetch: this.apiCallListener
+        ? createLoggingFetch(this.id, this.apiCallListener)
+        : undefined
     })
     this.sdkClientApiKey = apiKey ?? ''
     return this.sdkClient

package/src/providers/openai-compatible/validator-compiled.d.ts

@@ -0,0 +1,7 @@
+// AUTO-GENERATED by scripts/build-validators.mjs. Do not edit by hand.
+import type { ValidateFunction } from 'ajv'
+import type { OpenAICompatibleProviderConfig } from '../../settings.js'
+
+declare const validate: ValidateFunction<OpenAICompatibleProviderConfig>
+export default validate
+export { validate }

package/src/providers/openai-compatible/validator-compiled.js

@@ -0,0 +1,4 @@
+// AUTO-GENERATED by scripts/build-validators.mjs. Do not edit by hand.
+import __ajv_runtime_0 from "ajv/dist/runtime/ucs2length.js";
+const func2 = __ajv_runtime_0.default ?? __ajv_runtime_0;
+"use strict";export const validate = validate10;export default validate10;const schema11 = {"type":"object","required":["id","baseURL","models"],"additionalProperties":false,"properties":{"id":{"type":"string","minLength":1},"displayName":{"type":"string"},"baseURL":{"type":"string","minLength":1},"models":{"type":"array","minItems":1,"items":{"type":"object","required":["id"],"additionalProperties":false,"properties":{"id":{"type":"string","minLength":1},"displayName":{"type":"string"},"capabilities":{"type":"object","additionalProperties":false,"properties":{"supportsTools":{"type":"boolean"},"supportsImages":{"type":"boolean"},"supportsThinking":{"type":"boolean"},"supportsStreamingTools":{"type":"boolean"},"maxTokens":{"type":"integer","minimum":1}}}}}},"defaultModelId":{"type":"string"},"defaultFastModelId":{"type":"string"}}};function validate10(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;if(data && typeof data == "object" && !Array.isArray(data)){if(data.id === undefined){const err0 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "id"},message:"must have required property '"+"id"+"'"};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}if(data.baseURL === undefined){const err1 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "baseURL"},message:"must have required property '"+"baseURL"+"'"};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}if(data.models === undefined){const err2 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "models"},message:"must have required property '"+"models"+"'"};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}for(const key0 in data){if(!((((((key0 === "id") || (key0 === "displayName")) || (key0 === "baseURL")) || (key0 === "models")) || (key0 === "defaultModelId")) || (key0 === "defaultFastModelId"))){const err3 = {instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}}if(data.id !== undefined){let data0 = data.id;if(typeof data0 === "string"){if(func2(data0) < 1){const err4 = {instancePath:instancePath+"/id",schemaPath:"#/properties/id/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}}else {const err5 = {instancePath:instancePath+"/id",schemaPath:"#/properties/id/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;}}if(data.displayName !== undefined){if(typeof data.displayName !== "string"){const err6 = {instancePath:instancePath+"/displayName",schemaPath:"#/properties/displayName/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err6];}else {vErrors.push(err6);}errors++;}}if(data.baseURL !== undefined){let data2 = data.baseURL;if(typeof data2 === "string"){if(func2(data2) < 1){const err7 = {instancePath:instancePath+"/baseURL",schemaPath:"#/properties/baseURL/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"};if(vErrors === null){vErrors = [err7];}else {vErrors.push(err7);}errors++;}}else {const err8 = {instancePath:instancePath+"/baseURL",schemaPath:"#/properties/baseURL/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err8];}else {vErrors.push(err8);}errors++;}}if(data.models !== undefined){let data3 = data.models;if(Array.isArray(data3)){if(data3.length < 1){const err9 = {instancePath:instancePath+"/models",schemaPath:"#/properties/models/minItems",keyword:"minItems",params:{limit: 1},message:"must NOT have fewer than 1 items"};if(vErrors === null){vErrors = [err9];}else {vErrors.push(err9);}errors++;}const len0 = data3.length;for(let i0=0; i0<len0; i0++){let data4 = data3[i0];if(data4 && typeof data4 == "object" && !Array.isArray(data4)){if(data4.id === undefined){const err10 = {instancePath:instancePath+"/models/" + i0,schemaPath:"#/properties/models/items/required",keyword:"required",params:{missingProperty: "id"},message:"must have required property '"+"id"+"'"};if(vErrors === null){vErrors = [err10];}else {vErrors.push(err10);}errors++;}for(const key1 in data4){if(!(((key1 === "id") || (key1 === "displayName")) || (key1 === "capabilities"))){const err11 = {instancePath:instancePath+"/models/" + i0,schemaPath:"#/properties/models/items/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key1},message:"must NOT have additional properties"};if(vErrors === null){vErrors = [err11];}else {vErrors.push(err11);}errors++;}}if(data4.id !== undefined){let data5 = data4.id;if(typeof data5 === "string"){if(func2(data5) < 1){const err12 = {instancePath:instancePath+"/models/" + i0+"/id",schemaPath:"#/properties/models/items/properties/id/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"};if(vErrors === null){vErrors = [err12];}else {vErrors.push(err12);}errors++;}}else {const err13 = {instancePath:instancePath+"/models/" + i0+"/id",schemaPath:"#/properties/models/items/properties/id/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err13];}else {vErrors.push(err13);}errors++;}}if(data4.displayName !== undefined){if(typeof data4.displayName !== "string"){const err14 = {instancePath:instancePath+"/models/" + i0+"/displayName",schemaPath:"#/properties/models/items/properties/displayName/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err14];}else {vErrors.push(err14);}errors++;}}if(data4.capabilities !== undefined){let data7 = data4.capabilities;if(data7 && typeof data7 == "object" && !Array.isArray(data7)){for(const key2 in data7){if(!(((((key2 === "supportsTools") || (key2 === "supportsImages")) || (key2 === "supportsThinking")) || (key2 === "supportsStreamingTools")) || (key2 === "maxTokens"))){const err15 = {instancePath:instancePath+"/models/" + i0+"/capabilities",schemaPath:"#/properties/models/items/properties/capabilities/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key2},message:"must NOT have additional properties"};if(vErrors === null){vErrors = [err15];}else {vErrors.push(err15);}errors++;}}if(data7.supportsTools !== undefined){if(typeof data7.supportsTools !== "boolean"){const err16 = {instancePath:instancePath+"/models/" + i0+"/capabilities/supportsTools",schemaPath:"#/properties/models/items/properties/capabilities/properties/supportsTools/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err16];}else {vErrors.push(err16);}errors++;}}if(data7.supportsImages !== undefined){if(typeof data7.supportsImages !== "boolean"){const err17 = {instancePath:instancePath+"/models/" + i0+"/capabilities/supportsImages",schemaPath:"#/properties/models/items/properties/capabilities/properties/supportsImages/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err17];}else {vErrors.push(err17);}errors++;}}if(data7.supportsThinking !== undefined){if(typeof data7.supportsThinking !== "boolean"){const err18 = {instancePath:instancePath+"/models/" + i0+"/capabilities/supportsThinking",schemaPath:"#/properties/models/items/properties/capabilities/properties/supportsThinking/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err18];}else {vErrors.push(err18);}errors++;}}if(data7.supportsStreamingTools !== undefined){if(typeof data7.supportsStreamingTools !== "boolean"){const err19 = {instancePath:instancePath+"/models/" + i0+"/capabilities/supportsStreamingTools",schemaPath:"#/properties/models/items/properties/capabilities/properties/supportsStreamingTools/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err19];}else {vErrors.push(err19);}errors++;}}if(data7.maxTokens !== undefined){let data12 = data7.maxTokens;if(!(((typeof data12 == "number") && (!(data12 % 1) && !isNaN(data12))) && (isFinite(data12)))){const err20 = {instancePath:instancePath+"/models/" + i0+"/capabilities/maxTokens",schemaPath:"#/properties/models/items/properties/capabilities/properties/maxTokens/type",keyword:"type",params:{type: "integer"},message:"must be integer"};if(vErrors === null){vErrors = [err20];}else {vErrors.push(err20);}errors++;}if((typeof data12 == "number") && (isFinite(data12))){if(data12 < 1 || isNaN(data12)){const err21 = {instancePath:instancePath+"/models/" + i0+"/capabilities/maxTokens",schemaPath:"#/properties/models/items/properties/capabilities/properties/maxTokens/minimum",keyword:"minimum",params:{comparison: ">=", limit: 1},message:"must be >= 1"};if(vErrors === null){vErrors = [err21];}else {vErrors.push(err21);}errors++;}}}}else {const err22 = {instancePath:instancePath+"/models/" + i0+"/capabilities",schemaPath:"#/properties/models/items/properties/capabilities/type",keyword:"type",params:{type: "object"},message:"must be object"};if(vErrors === null){vErrors = [err22];}else {vErrors.push(err22);}errors++;}}}else {const err23 = {instancePath:instancePath+"/models/" + i0,schemaPath:"#/properties/models/items/type",keyword:"type",params:{type: "object"},message:"must be object"};if(vErrors === null){vErrors = [err23];}else {vErrors.push(err23);}errors++;}}}else {const err24 = {instancePath:instancePath+"/models",schemaPath:"#/properties/models/type",keyword:"type",params:{type: "array"},message:"must be array"};if(vErrors === null){vErrors = [err24];}else {vErrors.push(err24);}errors++;}}if(data.defaultModelId !== undefined){if(typeof data.defaultModelId !== "string"){const err25 = {instancePath:instancePath+"/defaultModelId",schemaPath:"#/properties/defaultModelId/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err25];}else {vErrors.push(err25);}errors++;}}if(data.defaultFastModelId !== undefined){if(typeof data.defaultFastModelId !== "string"){const err26 = {instancePath:instancePath+"/defaultFastModelId",schemaPath:"#/properties/defaultFastModelId/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err26];}else {vErrors.push(err26);}errors++;}}}else {const err27 = {instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"};if(vErrors === null){vErrors = [err27];}else {vErrors.push(err27);}errors++;}validate10.errors = vErrors;return errors === 0;}

package/src/providers/openai-compatible/validator.ts

@@ -0,0 +1,33 @@
+import type { ErrorObject } from 'ajv'
+import type { OpenAICompatibleProviderConfig } from '../../settings.js'
+import validate from './validator-compiled.js'
+
+const formatErrors = (
+  errors: ReadonlyArray<ErrorObject> | null | undefined
+): string => {
+  if (!errors || errors.length === 0) return 'unknown validation error'
+  return errors
+    .map(e => `config${e.instancePath ?? ''} ${e.message ?? ''}`.trim())
+    .join(', ')
+}
+
+/**
+ * Throws if `config` doesn't conform to the OpenAI-compatible provider schema.
+ *
+ * The validator is precompiled to a standalone ESM module by
+ * `scripts/build-validators.mjs`, so loading this module does not call
+ * `new Function(...)` — making it safe to use in Electron renderer processes
+ * under a strict CSP without `unsafe-eval`.
+ *
+ * Catches the kinds of mistakes a settings UI or hand-written config can make:
+ * missing required fields, wrong types, unknown keys, empty `models[]`, or an
+ * empty string where a non-empty one is required.
+ */
+export const validateOpenAICompatibleProviderConfig = (
+  config: OpenAICompatibleProviderConfig
+): void => {
+  if (validate(config)) return
+  throw new Error(
+    `Invalid OpenAI-compatible provider config: ${formatErrors(validate.errors)}`
+  )
+}