@onyx.dev/onyx-database 1.1.0 → 2.0.0

package/dist/{aggregates-DodZNu9-.d.ts → aggregates-BJT5DGGX.d.ts}

@@ -814,10 +814,18 @@ interface RetryOptions {
 }
 interface OnyxConfig {
     baseUrl?: string;
+    /**
+     * Base URL for AI endpoints. Defaults to https://ai.onyx.dev.
+     */
+    aiBaseUrl?: string;
     databaseId?: string;
     apiKey?: string;
     apiSecret?: string;
     fetch?: FetchImpl;
+    /**
+     * Default AI model when using shorthand chat calls (`db.chat('...')`). Defaults to `onyx`.
+     */
+    defaultModel?: string;
     /**
      * Default partition for queries, `findById`, and deletes when removing by
      * primary key. Saves rely on the entity's partition field instead.
@@ -840,7 +848,306 @@ interface OnyxConfig {
      */
     retry?: RetryOptions;
 }
+interface AiRequestOptions {
+    /**
+     * Optional database scope for AI calls. Defaults to the configured databaseId.
+     */
+    databaseId?: string;
+}
+type AiChatRole = 'system' | 'user' | 'assistant' | 'tool';
+interface AiToolCallFunction {
+    name: string;
+    arguments: string;
+}
+interface AiToolCall {
+    id?: string | null;
+    type?: string | null;
+    function: AiToolCallFunction;
+}
+interface AiChatMessage {
+    role: AiChatRole;
+    content?: string | null;
+    tool_calls?: AiToolCall[] | null;
+    tool_call_id?: string | null;
+    name?: string | null;
+}
+interface AiToolFunction {
+    name: string;
+    description?: string | null;
+    parameters?: Record<string, unknown> | null;
+}
+interface AiTool {
+    type: string;
+    function: AiToolFunction;
+}
+type AiToolChoice = 'none' | 'auto' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+} | null;
+interface AiChatCompletionRequest {
+    model: string;
+    messages: AiChatMessage[];
+    stream?: boolean;
+    temperature?: number | null;
+    top_p?: number | null;
+    max_tokens?: number | null;
+    metadata?: Record<string, unknown>;
+    tools?: AiTool[];
+    tool_choice?: AiToolChoice;
+    user?: string | null;
+}
+interface AiChatCompletionUsage {
+    prompt_tokens?: number | null;
+    completion_tokens?: number | null;
+    total_tokens?: number | null;
+}
+interface AiChatCompletionChoice {
+    index: number;
+    message: AiChatMessage;
+    finish_reason?: string | null;
+}
+interface AiChatCompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: AiChatCompletionChoice[];
+    usage?: AiChatCompletionUsage;
+}
+interface AiChatCompletionChunkDelta {
+    role?: AiChatRole | null;
+    content?: string | null;
+    tool_calls?: AiToolCall[] | null;
+    tool_call_id?: string | null;
+    name?: string | null;
+}
+interface AiChatCompletionChunkChoice {
+    index: number;
+    delta: AiChatCompletionChunkDelta;
+    finish_reason?: string | null;
+}
+interface AiChatCompletionChunk {
+    id: string;
+    object: string;
+    created: number;
+    model?: string | null;
+    choices: AiChatCompletionChunkChoice[];
+}
+interface AiChatCompletionStream extends AsyncIterable<AiChatCompletionChunk> {
+    cancel(): void;
+}
+interface AiChatOptions extends AiRequestOptions {
+    /**
+     * Model to use for the shorthand `db.chat()` call. Defaults to config.defaultModel or `onyx`.
+     */
+    model?: string;
+    /**
+     * Role for the constructed message. Defaults to `user`.
+     */
+    role?: AiChatRole;
+    /**
+     * Temperature for the completion. Omit to use the service default.
+     */
+    temperature?: number | null;
+    /**
+     * Enable SSE streaming. Defaults to `false`.
+     */
+    stream?: boolean;
+    /**
+     * When true, return the raw completion response instead of the first message content.
+     */
+    raw?: boolean;
+}
+interface AiChatClient {
+    create(request: AiChatCompletionRequest & {
+        stream?: false;
+    }, options?: AiRequestOptions): Promise<AiChatCompletionResponse>;
+    create(request: AiChatCompletionRequest & {
+        stream: true;
+    }, options?: AiRequestOptions): Promise<AiChatCompletionStream>;
+    create(request: AiChatCompletionRequest, options?: AiRequestOptions): Promise<AiChatCompletionResponse | AiChatCompletionStream>;
+}
+interface AiScriptApprovalRequest {
+    script: string;
+}
+interface AiScriptApprovalResponse {
+    normalizedScript: string;
+    expiresAtIso: string;
+    requiresApproval: boolean;
+    findings?: string;
+}
+interface AiModelsResponse {
+    object: string;
+    data: AiModel[];
+}
+interface AiModel {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+}
+interface AiErrorResponse {
+    error?: string | {
+        message?: string;
+        [key: string]: unknown;
+    } | null;
+}
+interface AiClient {
+    /**
+     * Run a chat completion. Accepts shorthand strings or full requests.
+     *
+     * @example
+     * ```ts
+     * const quick = await db.ai.chat('Summarize last week.'); // returns first message content
+     * const completion = await db.ai.chat(
+     *   { model: 'onyx-chat', messages: [{ role: 'user', content: 'Summarize last week.' }] },
+     *   { databaseId: 'db1', raw: true }, // returns full response
+     * );
+     * ```
+     */
+    chat(content: string, options?: AiChatOptions & {
+        stream?: false;
+        raw?: false | undefined;
+    }): Promise<string>;
+    chat(content: string, options: AiChatOptions & {
+        stream: true;
+    }): Promise<AiChatCompletionStream>;
+    chat(content: string, options: AiChatOptions & {
+        raw: true;
+    }): Promise<AiChatCompletionResponse | AiChatCompletionStream>;
+    chat(request: AiChatCompletionRequest & {
+        stream?: false;
+    }, options?: AiRequestOptions): Promise<AiChatCompletionResponse>;
+    chat(request: AiChatCompletionRequest & {
+        stream: true;
+    }, options?: AiRequestOptions): Promise<AiChatCompletionStream>;
+    chat(request: AiChatCompletionRequest, options?: AiRequestOptions): Promise<AiChatCompletionResponse | AiChatCompletionStream>;
+    /**
+     * Access the chat client for more control over streaming and cancellation.
+     */
+    chatClient(): AiChatClient;
+    /**
+     * List available AI models.
+     *
+     * @example
+     * ```ts
+     * const models = await db.ai.getModels();
+     * ```
+     */
+    getModels(): Promise<AiModelsResponse>;
+    /**
+     * Retrieve a single AI model by ID.
+     *
+     * @example
+     * ```ts
+     * const model = await db.ai.getModel('onyx-chat');
+     * ```
+     */
+    getModel(modelId: string): Promise<AiModel>;
+    /**
+     * Request mutation approval for a script.
+     *
+     * @example
+     * ```ts
+     * const approval = await db.ai.requestScriptApproval({
+     *   script: "db.save({ id: 'u1', email: 'a@b.com' })"
+     * });
+     * ```
+     */
+    requestScriptApproval(input: AiScriptApprovalRequest): Promise<AiScriptApprovalResponse>;
+}
 interface IOnyxDatabase<Schema = Record<string, unknown>> {
+    /**
+     * AI helpers (chat, models, script approvals) grouped under `db.ai`.
+     *
+     * @example
+     * ```ts
+     * const completion = await db.ai.chat({
+     *   model: 'onyx-chat',
+     *   messages: [{ role: 'user', content: 'Summarize last week.' }],
+     * });
+     * ```
+     */
+    ai: AiClient;
+    /**
+     * Access OpenAI-compatible chat completions via `db.chat('...')` or `db.chat().create(...)`.
+     *
+     * @example
+     * ```ts
+     * const completion = await db.chat('Summarize last week.'); // returns first message content
+     * ```
+     *
+     * @example
+     * ```ts
+     * const chat = db.chat();
+     * const completion = await chat.create({
+     *   model: 'onyx-chat',
+     *   messages: [{ role: 'user', content: 'Summarize last week.' }],
+     * });
+     * ```
+     *
+     * @example
+     * ```ts
+     * const stream = await db
+     *   .chat()
+     *   .create({
+     *     model: 'onyx-chat',
+     *     stream: true,
+     *     messages: [{ role: 'user', content: 'Draft an onboarding checklist.' }],
+     *   });
+     * for await (const chunk of stream) {
+     *   process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
+     * }
+     * ```
+     */
+    chat(content: string, options?: AiChatOptions & {
+        stream?: false;
+        raw?: false | undefined;
+    }): Promise<string>;
+    chat(content: string, options: AiChatOptions & {
+        stream: true;
+    }): Promise<AiChatCompletionStream>;
+    chat(content: string, options: AiChatOptions & {
+        raw: true;
+    }): Promise<AiChatCompletionResponse | AiChatCompletionStream>;
+    chat(): AiChatClient;
+    /**
+     * List available AI models.
+     *
+     * @deprecated Prefer `db.ai.getModels()`.
+     *
+     * @example
+     * ```ts
+     * const models = await db.getModels();
+     * ```
+     */
+    getModels(): Promise<AiModelsResponse>;
+    /**
+     * Retrieve a single AI model by ID.
+     *
+     * @deprecated Prefer `db.ai.getModel(...)`.
+     *
+     * @example
+     * ```ts
+     * const model = await db.getModel('onyx-chat');
+     * ```
+     */
+    getModel(modelId: string): Promise<AiModel>;
+    /**
+     * Request mutation approval for a script.
+     *
+     * @deprecated Prefer `db.ai.requestScriptApproval(...)`.
+     *
+     * @example
+     * ```ts
+     * const approval = await db.requestScriptApproval({
+     *   script: "db.save({ id: 'u1', email: 'a@b.com' })"
+     * });
+     * ```
+     */
+    requestScriptApproval(input: AiScriptApprovalRequest): Promise<AiScriptApprovalResponse>;
     /**
      * Begin a query against a table.
      *
@@ -1450,4 +1757,4 @@ declare const substring: (attribute: string, from: number, length: number) => st
 declare const replace: (attribute: string, pattern: string, repl: string) => string;
 declare const percentile: (attribute: string, p: number) => string;
 
-export { inOp as $, type QueryCriteriaOperator as A, type Sort as B, type StreamAction as C, type OnyxDocument as D, type FetchResponse as E, type FullTextQuery as F, type FetchImpl as G, type QueryCriteria as H, type IOnyxDatabase as I, type QueryCondition as J, type SelectQuery as K, type LogicalOperator as L, type QueryPage as M, type IConditionBuilder as N, type OnyxFacade as O, type IQueryBuilder as P, QueryResults as Q, type RetryOptions as R, type SecretMetadata as S, type ISaveBuilder as T, type UpdateQuery as U, type ICascadeBuilder as V, type ICascadeRelationshipBuilder as W, asc as X, desc as Y, eq as Z, neq as _, type QueryResultsPromise as a, within as a0, notIn as a1, notWithin as a2, between as a3, gt as a4, gte as a5, lt as a6, lte as a7, matches as a8, search as a9, notMatches as aa, like as ab, notLike as ac, contains as ad, containsIgnoreCase as ae, notContains as af, notContainsIgnoreCase as ag, startsWith as ah, notStartsWith as ai, isNull as aj, notNull as ak, avg as al, sum as am, count as an, min as ao, max as ap, std as aq, variance as ar, median as as, upper as at, lower as au, substring as av, replace as aw, percentile as ax, type OnyxConfig as b, type SecretRecord as c, type SecretsListResponse as d, type SecretSaveRequest as e, type SchemaDataType as f, type SchemaIdentifierGenerator as g, type SchemaIdentifier as h, type SchemaAttribute as i, type SchemaIndexType as j, type SchemaIndex as k, type SchemaResolver as l, type SchemaTriggerEvent as m, type SchemaTrigger as n, type SchemaEntity as o, type SchemaRevisionMetadata as p, type SchemaRevision as q, type SchemaHistoryEntry as r, type SchemaUpsertRequest as s, type SchemaValidationResult as t, type SchemaAttributeChange as u, type SchemaIndexChange as v, type SchemaResolverChange as w, type SchemaTriggerChange as x, type SchemaTableDiff as y, type SchemaDiff as z };
+export { type SchemaTriggerChange as $, type AiRequestOptions as A, type SecretsListResponse as B, type SecretSaveRequest as C, type SchemaDataType as D, type SchemaIdentifierGenerator as E, type FullTextQuery as F, type SchemaIdentifier as G, type SchemaAttribute as H, type IOnyxDatabase as I, type SchemaIndexType as J, type SchemaIndex as K, type SchemaResolver as L, type SchemaTriggerEvent as M, type SchemaTrigger as N, type OnyxFacade as O, type SchemaEntity as P, QueryResults as Q, type RetryOptions as R, type SecretMetadata as S, type SchemaRevisionMetadata as T, type SchemaRevision as U, type SchemaHistoryEntry as V, type SchemaUpsertRequest as W, type SchemaValidationResult as X, type SchemaAttributeChange as Y, type SchemaIndexChange as Z, type SchemaResolverChange as _, type QueryResultsPromise as a, type SchemaTableDiff as a0, type SchemaDiff as a1, type QueryCriteriaOperator as a2, type LogicalOperator as a3, type Sort as a4, type StreamAction as a5, type OnyxDocument as a6, type FetchResponse as a7, type FetchImpl as a8, type QueryCriteria as a9, notLike as aA, contains as aB, containsIgnoreCase as aC, notContains as aD, notContainsIgnoreCase as aE, startsWith as aF, notStartsWith as aG, isNull as aH, notNull as aI, avg as aJ, sum as aK, count as aL, min as aM, max as aN, std as aO, variance as aP, median as aQ, upper as aR, lower as aS, substring as aT, replace as aU, percentile as aV, type QueryCondition as aa, type SelectQuery as ab, type UpdateQuery as ac, type QueryPage as ad, type IConditionBuilder as ae, type IQueryBuilder as af, type ISaveBuilder as ag, type ICascadeBuilder as ah, type ICascadeRelationshipBuilder as ai, asc as aj, desc as ak, eq as al, neq as am, inOp as an, within as ao, notIn as ap, notWithin as aq, between as ar, gt as as, gte as at, lt as au, lte as av, matches as aw, search as ax, notMatches as ay, like as az, type OnyxConfig as b, type AiChatRole as c, type AiToolCallFunction as d, type AiToolCall as e, type AiChatMessage as f, type AiToolFunction as g, type AiTool as h, type AiToolChoice as i, type AiChatCompletionRequest as j, type AiChatCompletionUsage as k, type AiChatCompletionChoice as l, type AiChatCompletionResponse as m, type AiChatCompletionChunkDelta as n, type AiChatCompletionChunkChoice as o, type AiChatCompletionChunk as p, type AiChatCompletionStream as q, type AiChatOptions as r, type AiChatClient as s, type AiScriptApprovalRequest as t, type AiScriptApprovalResponse as u, type AiModelsResponse as v, type AiModel as w, type AiErrorResponse as x, type AiClient as y, type SecretRecord as z };

package/dist/edge.cjs

@@ -2,6 +2,8 @@
 
 // src/config/defaults.ts
 var DEFAULT_BASE_URL = "https://api.onyx.dev";
+var DEFAULT_AI_BASE_URL = "https://ai.onyx.dev";
+var DEFAULT_AI_MODEL = "onyx";
 var sanitizeBaseUrl = (u) => u.replace(/\/+$/, "");
 
 // src/errors/config-error.ts
@@ -53,6 +55,8 @@ function readEnv(targetId) {
   if (targetId && envId !== targetId) return {};
   const res = dropUndefined({
     baseUrl: pick("ONYX_DATABASE_BASE_URL"),
+    aiBaseUrl: pick("ONYX_AI_BASE_URL"),
+    defaultModel: pick("ONYX_DEFAULT_MODEL"),
     databaseId: envId,
     apiKey: pick("ONYX_DATABASE_API_KEY"),
     apiSecret: pick("ONYX_DATABASE_API_SECRET")
@@ -71,11 +75,15 @@ async function resolveConfig(input) {
   const env = readEnv(input?.databaseId);
   const merged = {
     baseUrl: DEFAULT_BASE_URL,
+    aiBaseUrl: DEFAULT_AI_BASE_URL,
+    defaultModel: DEFAULT_AI_MODEL,
     ...dropUndefined(env),
     ...dropUndefined(input)
   };
   dbg("merged (pre-validate):", mask(merged));
   const baseUrl = sanitizeBaseUrl(merged.baseUrl ?? DEFAULT_BASE_URL);
+  const aiBaseUrl = sanitizeBaseUrl(merged.aiBaseUrl ?? DEFAULT_AI_BASE_URL);
+  const defaultModel = typeof merged.defaultModel === "string" && merged.defaultModel.trim() ? merged.defaultModel.trim() : DEFAULT_AI_MODEL;
   const databaseId = merged.databaseId ?? "";
   const apiKey = merged.apiKey ?? "";
   const apiSecret = merged.apiSecret ?? "";
@@ -100,6 +108,8 @@ async function resolveConfig(input) {
   }
   const resolved = {
     baseUrl,
+    aiBaseUrl,
+    defaultModel,
     databaseId,
     apiKey,
     apiSecret,
@@ -1120,38 +1130,69 @@ var OnyxDatabaseImpl = class {
   cfgPromise;
   resolved = null;
   http = null;
+  aiHttp = null;
   streams = /* @__PURE__ */ new Set();
   requestLoggingEnabled;
   responseLoggingEnabled;
   defaultPartition;
+  ai;
   constructor(config, resolveConfigWithCache) {
     this.requestLoggingEnabled = !!config?.requestLoggingEnabled;
     this.responseLoggingEnabled = !!config?.responseLoggingEnabled;
     this.defaultPartition = config?.partition;
     this.cfgPromise = resolveConfigWithCache(config);
+    this.ai = this.createAiFacade();
   }
-  async ensureClient() {
+  async resolveConfig() {
     if (!this.resolved) {
       this.resolved = await this.cfgPromise;
     }
+    return this.resolved;
+  }
+  async ensureClient() {
+    const cfg = await this.resolveConfig();
     if (!this.http) {
       this.http = new HttpClient({
-        baseUrl: this.resolved.baseUrl,
-        apiKey: this.resolved.apiKey,
-        apiSecret: this.resolved.apiSecret,
-        fetchImpl: this.resolved.fetch,
+        baseUrl: cfg.baseUrl,
+        apiKey: cfg.apiKey,
+        apiSecret: cfg.apiSecret,
+        fetchImpl: cfg.fetch,
         requestLoggingEnabled: this.requestLoggingEnabled,
         responseLoggingEnabled: this.responseLoggingEnabled,
-        retryEnabled: this.resolved.retryEnabled,
-        maxRetries: this.resolved.maxRetries,
-        retryInitialDelayMs: this.resolved.retryInitialDelayMs
+        retryEnabled: cfg.retryEnabled,
+        maxRetries: cfg.maxRetries,
+        retryInitialDelayMs: cfg.retryInitialDelayMs
       });
     }
     return {
       http: this.http,
-      fetchImpl: this.resolved.fetch,
-      baseUrl: this.resolved.baseUrl,
-      databaseId: this.resolved.databaseId
+      fetchImpl: cfg.fetch,
+      baseUrl: cfg.baseUrl,
+      databaseId: cfg.databaseId,
+      defaultModel: cfg.defaultModel ?? DEFAULT_AI_MODEL
+    };
+  }
+  async ensureAiClient() {
+    const cfg = await this.resolveConfig();
+    if (!this.aiHttp) {
+      this.aiHttp = new HttpClient({
+        baseUrl: cfg.aiBaseUrl,
+        apiKey: cfg.apiKey,
+        apiSecret: cfg.apiSecret,
+        fetchImpl: cfg.fetch,
+        requestLoggingEnabled: this.requestLoggingEnabled,
+        responseLoggingEnabled: this.responseLoggingEnabled,
+        retryEnabled: cfg.retryEnabled,
+        maxRetries: cfg.maxRetries,
+        retryInitialDelayMs: cfg.retryInitialDelayMs
+      });
+    }
+    return {
+      http: this.aiHttp,
+      fetchImpl: cfg.fetch,
+      aiBaseUrl: cfg.aiBaseUrl,
+      databaseId: cfg.databaseId,
+      defaultModel: cfg.defaultModel ?? DEFAULT_AI_MODEL
     };
   }
   registerStream(handle) {
@@ -1166,7 +1207,75 @@ var OnyxDatabaseImpl = class {
       }
     };
   }
+  createAiFacade() {
+    const chat = ((contentOrRequest, options) => {
+      if (typeof contentOrRequest === "string") {
+        return this.chatWithContent(contentOrRequest, options);
+      }
+      return this.getAiChatClient().create(contentOrRequest, options);
+    });
+    return {
+      chat,
+      chatClient: () => this.getAiChatClient(),
+      getModels: () => this.getModels(),
+      getModel: (modelId) => this.getModel(modelId),
+      requestScriptApproval: (input) => this.requestScriptApproval(input)
+    };
+  }
+  getRequestLoggingEnabled() {
+    return this.requestLoggingEnabled;
+  }
+  getResponseLoggingEnabled() {
+    return this.responseLoggingEnabled;
+  }
   /** -------- IOnyxDatabase -------- */
+  getAiChatClient() {
+    return new AiChatClientImpl(
+      () => this.ensureAiClient(),
+      (handle) => this.registerStream(handle),
+      () => this.requestLoggingEnabled,
+      () => this.responseLoggingEnabled
+    );
+  }
+  async chatWithContent(content, options) {
+    const { defaultModel } = await this.ensureAiClient();
+    const stream = options?.stream ?? false;
+    const request = {
+      model: options?.model ?? defaultModel,
+      messages: [{ role: options?.role ?? "user", content }],
+      stream
+    };
+    if (options && "temperature" in options) {
+      request.temperature = options.temperature ?? null;
+    }
+    const result = await this.getAiChatClient().create(request, options);
+    if (stream) return result;
+    if (options?.raw) return result;
+    const first = result.choices?.[0]?.message?.content;
+    if (typeof first === "string" && first.trim().length > 0) {
+      return first;
+    }
+    throw new Error("Chat completion response is missing message content");
+  }
+  chat(content, options) {
+    if (typeof content === "string") {
+      return this.chatWithContent(content, options);
+    }
+    return this.getAiChatClient();
+  }
+  async getModels() {
+    const { http } = await this.ensureAiClient();
+    return http.request("GET", "/v1/models");
+  }
+  async getModel(modelId) {
+    const { http } = await this.ensureAiClient();
+    const path = `/v1/models/${encodeURIComponent(modelId)}`;
+    return http.request("GET", path);
+  }
+  async requestScriptApproval(input) {
+    const { http } = await this.ensureAiClient();
+    return http.request("POST", "/api/script-approvals", input);
+  }
   from(table) {
     return new QueryBuilderImpl(this, String(table), this.defaultPartition);
   }
@@ -1716,6 +1825,153 @@ var CascadeBuilderImpl = class {
     return this.db.delete(table, primaryKey, opts);
   }
 };
+var AiChatClientImpl = class {
+  constructor(resolveAiClient, registerStream, requestLoggingEnabled, responseLoggingEnabled) {
+    this.resolveAiClient = resolveAiClient;
+    this.registerStream = registerStream;
+    this.requestLoggingEnabled = requestLoggingEnabled;
+    this.responseLoggingEnabled = responseLoggingEnabled;
+  }
+  normalizeEventData(rawEvent) {
+    const lines = rawEvent.split("\n");
+    const dataLines = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith(":")) continue;
+      if (trimmed.startsWith("data:")) {
+        dataLines.push(trimmed.slice(5).trim());
+      } else {
+        dataLines.push(trimmed);
+      }
+    }
+    if (!dataLines.length) return null;
+    const joined = dataLines.join("\n").trim();
+    return joined.length > 0 ? joined : null;
+  }
+  logRequest(url, body, headers) {
+    if (!this.requestLoggingEnabled()) return;
+    console.log(`POST ${url}`);
+    if (body != null) {
+      const serialized = typeof body === "string" ? body : JSON.stringify(body);
+      console.log(serialized);
+    }
+    const headerLog = { ...headers };
+    if (headerLog["x-onyx-secret"]) headerLog["x-onyx-secret"] = "[REDACTED]";
+    console.log("Headers:", headerLog);
+  }
+  logResponse(status, statusText, raw) {
+    if (!this.responseLoggingEnabled()) return;
+    const statusLine = `${status} ${statusText}`.trim();
+    console.log(statusLine);
+    if (raw && raw.trim().length > 0) {
+      console.log(raw);
+    }
+  }
+  toOnyxError(status, statusText, raw) {
+    let parsed = raw;
+    try {
+      parsed = parseJsonAllowNaN(raw);
+    } catch {
+    }
+    const message = typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error === "object" && typeof parsed.error?.message === "string" ? String(parsed.error.message) : `${status} ${statusText}`;
+    return new OnyxHttpError(message, status, statusText, parsed, raw);
+  }
+  async create(request, options) {
+    const body = { ...request, stream: !!request.stream };
+    const { http, fetchImpl, aiBaseUrl, databaseId } = await this.resolveAiClient();
+    const params = new URLSearchParams();
+    const scopedDb = options?.databaseId ?? databaseId;
+    if (scopedDb) params.append("databaseId", scopedDb);
+    const path = `/v1/chat/completions${params.size ? `?${params.toString()}` : ""}`;
+    if (!body.stream) {
+      return http.request("POST", path, body);
+    }
+    const url = `${aiBaseUrl}${path}`;
+    const headers = http.headers({ Accept: "text/event-stream" });
+    this.logRequest(url, body, headers);
+    const res = await fetchImpl(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const raw = await res.text();
+      this.logResponse(res.status, res.statusText, raw);
+      throw this.toOnyxError(res.status, res.statusText, raw);
+    }
+    this.logResponse(res.status, res.statusText);
+    const bodyStream = res.body;
+    const reader = bodyStream && typeof bodyStream.getReader === "function" ? bodyStream.getReader() : null;
+    if (!reader) {
+      throw new OnyxHttpError(
+        "Streaming response body is not readable",
+        res.status,
+        res.statusText,
+        null,
+        ""
+      );
+    }
+    let canceled = false;
+    const handle = {
+      cancel: () => {
+        if (canceled) return;
+        canceled = true;
+        try {
+          reader.cancel?.();
+        } catch {
+        }
+      }
+    };
+    const registered = this.registerStream(handle);
+    const normalizeEvent = (rawEvent) => this.normalizeEventData(rawEvent);
+    const stream = {
+      async *[Symbol.asyncIterator]() {
+        const decoder = new TextDecoder("utf-8");
+        let buffer = "";
+        try {
+          while (!canceled) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (value) {
+              buffer += decoder.decode(value, { stream: true });
+            }
+            let splitIndex = buffer.indexOf("\n\n");
+            while (splitIndex !== -1) {
+              const rawEvent = buffer.slice(0, splitIndex);
+              buffer = buffer.slice(splitIndex + 2);
+              const data = normalizeEvent(rawEvent);
+              if (data === "[DONE]") return;
+              if (data) {
+                try {
+                  yield parseJsonAllowNaN(data);
+                } catch {
+                }
+              }
+              splitIndex = buffer.indexOf("\n\n");
+            }
+          }
+          buffer += decoder.decode();
+          const remaining = buffer.trim();
+          if (remaining && remaining !== "[DONE]") {
+            const data = normalizeEvent(remaining);
+            if (data && data !== "[DONE]") {
+              try {
+                yield parseJsonAllowNaN(data);
+              } catch {
+              }
+            }
+          }
+        } finally {
+          registered.cancel();
+        }
+      },
+      cancel() {
+        registered.cancel();
+      }
+    };
+    return stream;
+  }
+};
 function createOnyxFacade(resolveConfig2) {
   let cachedCfg = null;
   function resolveConfigWithCache(config) {