@odla-ai/ai 0.1.2 → 0.2.0

package/README.md

@@ -252,6 +252,33 @@ is a *privileged* action (operator or `odla_dev_` token, via `provisionAgentApp`
 never returned to browser clients. `OdlaDbMemory` persists conversation turns and
 `persistRun` writes run traces, both as natural-key upserts (idempotent on retry).
 
+### Platform apps (odla.ai)
+
+For apps registered on the odla platform, LLM access is an **app setting**:
+provider + default model live in the registry per environment (Studio's AI
+card, or `@odla-ai/apps` `setAi`), and the API key lives in the platform
+vault — the env's odla-db tenant secrets. `initFromPlatform` reads both:
+
+```ts
+import { initFromPlatform } from "@odla-ai/ai";
+import { init as odlaInit } from "@odla-ai/db";
+
+const db = odlaInit({ appId: TENANT, adminToken: env.ODLA_API_KEY, endpoint: "https://db.odla.ai" });
+const { ai, provider, model } = await initFromPlatform({
+  platform: "https://odla.ai",
+  appId: APP_ID,          // the registry app id, not the tenant
+  env: "prod",
+  db,
+});
+```
+
+The config comes from the anonymous `public-config` endpoint and is cached
+(~60s by default), so switching provider or model in Studio takes effect
+without a redeploy; the key resolves from the vault at call time, so rotation
+is just writing the secret again. **Never put provider keys in an app
+Worker's wrangler vars/secrets** — the worker's only secret is its odla-db
+app key.
+
 ## Models & capabilities
 
 The catalog maps a canonical model id → provider, native id, and capabilities.

package/dist/index.cjs

@@ -5,8 +5,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -438,6 +443,7 @@ function buildParams2(spec, req, stream) {
       json_schema: { name: req.responseFormat.name ?? "response", schema: req.responseFormat.schema }
     };
   }
+  if (req.webSearch) params.web_search_options = { search_context_size: "medium" };
   if (stream) {
     params.stream = true;
     params.stream_options = { include_usage: true };
@@ -903,6 +909,7 @@ __export(index_exports, {
   blocksOf: () => blocksOf,
   buildCatalog: () => buildCatalog,
   chatCapabilities: () => chatCapabilities,
+  clearPlatformAiCache: () => clearPlatformAiCache,
   clearProviderCache: () => clearProviderCache,
   composeSkills: () => composeSkills,
   createApp: () => createApp,
@@ -916,6 +923,7 @@ __export(index_exports, {
   getProvider: () => getProvider,
   includes: () => includes,
   init: () => init,
+  initFromPlatform: () => initFromPlatform,
   isAudioBlock: () => isAudioBlock,
   isDocumentBlock: () => isDocumentBlock,
   isImageBlock: () => isImageBlock,
@@ -1069,6 +1077,22 @@ var OPENAI_MODELS = [
     capabilities: chatCapabilities({ effort: true }),
     contextWindow: 4e5
   },
+  {
+    id: "gpt-5-nano",
+    provider: "openai",
+    nativeId: "gpt-5-nano",
+    capabilities: chatCapabilities({ effort: true }),
+    contextWindow: 4e5
+  },
+  {
+    // Search-tuned chat model: the adapter sends web_search_options when a
+    // request sets webSearch. No reasoning-effort knob.
+    id: "gpt-5-search-api",
+    provider: "openai",
+    nativeId: "gpt-5-search-api",
+    capabilities: chatCapabilities({ webSearch: true }),
+    contextWindow: 4e5
+  },
   {
     // Non-reasoning multimodal chat (image input, no effort knob).
     id: "gpt-4o",
@@ -1390,6 +1414,27 @@ Secrets are read-only from the app key (odlaDbKeyResolver \u2192 db.secrets.get)
 are WRITTEN only with the operator/dev token via provisionAgentApp/putSecret. Keys
 are AES-GCM-encrypted at rest in odla-db and never returned to browser clients.
 
+## Platform wiring (odla.ai apps registry)
+
+Apps registered on the odla platform get LLM access as an APP SETTING \u2014
+never put provider keys in your Worker's wrangler vars/secrets. Provider +
+default model are per-environment registry config (set in Studio's AI card
+or \`@odla-ai/apps\` setAi); the API key lives in the platform vault (the
+env's odla-db tenant secrets, write-only for operators). One call reads both:
+
+    import { initFromPlatform } from "@odla-ai/ai";
+    import { init as odlaInit } from "@odla-ai/db";
+
+    const db = odlaInit({ appId: TENANT, adminToken: env.ODLA_API_KEY, endpoint: "https://db.odla.ai" });
+    const { ai, provider, model } = await initFromPlatform({
+      platform: "https://odla.ai", appId: APP_ID, env: "prod", db });
+    // ai.chat / ai.stream / ai.extract \u2014 provider/model from public-config
+    // (cached ~60s, so Studio changes apply without redeploys); the key is
+    // fetched from the vault at call time via odlaDbKeyResolver.
+
+The only secret the Worker carries is its odla-db app key. Rotating the LLM
+key = writing the secret again; switching provider/model = a Studio edit.
+
 ## Errors
 
 Every error is an OdlaAIError subclass with a stable \`code\` \u2014 branch on err.code:
@@ -1826,15 +1871,15 @@ var DEFAULT_SECRET_NAMES = {
 function odlaDbKeyResolver(db, opts = {}) {
   const nameFor = opts.secretName ?? ((p) => DEFAULT_SECRET_NAMES[p]);
   const useCache = opts.cache ?? true;
-  const cache2 = /* @__PURE__ */ new Map();
+  const cache3 = /* @__PURE__ */ new Map();
   return async (provider) => {
     if (useCache) {
-      const hit = cache2.get(provider);
+      const hit = cache3.get(provider);
       if (hit !== void 0) return hit;
     }
     try {
       const key = await db.secrets.get(nameFor(provider));
-      if (useCache) cache2.set(provider, key);
+      if (useCache) cache3.set(provider, key);
       return key;
     } catch {
       return void 0;
@@ -1842,6 +1887,52 @@ function odlaDbKeyResolver(db, opts = {}) {
   };
 }
 
+// src/store/platform.ts
+init_shape();
+var cache2 = /* @__PURE__ */ new Map();
+function clearPlatformAiCache() {
+  cache2.clear();
+}
+async function fetchAiConfig(opts) {
+  const doFetch = opts.fetch ?? fetch;
+  const base = opts.platform.replace(/\/$/, "");
+  const url = `${base}/registry/apps/${encodeURIComponent(opts.appId)}/public-config?env=${encodeURIComponent(opts.env)}`;
+  const res = await doFetch(url);
+  if (!res.ok) throw new ProviderError(`platform public-config fetch failed: ${res.status} for ${opts.appId}/${opts.env}`);
+  const cfg = await res.json();
+  const ai = cfg.ai;
+  if (!ai || typeof ai.provider !== "string") {
+    throw new ConfigError(
+      `ai service is not enabled/configured for "${opts.appId}" (${opts.env}) \u2014 enable it in Studio or via @odla-ai/apps setAi(appId, env, { provider }).`
+    );
+  }
+  if (!(ai.provider in DEFAULT_SECRET_NAMES)) {
+    throw new ConfigError(`platform ai config names unknown provider "${ai.provider}" for "${opts.appId}" (${opts.env}).`);
+  }
+  const model = typeof ai.model === "string" && ai.model ? ai.model : void 0;
+  return { provider: ai.provider, ...model ? { model } : {} };
+}
+async function initFromPlatform(opts) {
+  const ttl = opts.ttlMs ?? 6e4;
+  const key = `${opts.platform}|${opts.appId}|${opts.env}`;
+  const now = Date.now();
+  const hit = ttl > 0 ? cache2.get(key) : void 0;
+  if (hit && hit.expiresAt > now) return hit.value;
+  const { provider, model } = await fetchAiConfig(opts);
+  if (hit && hit.value.provider === provider && hit.value.model === model) {
+    hit.expiresAt = now + ttl;
+    return hit.value;
+  }
+  const ai = init({
+    ...opts.initOptions,
+    resolveKey: odlaDbKeyResolver(opts.db),
+    defaultModel: model ?? opts.initOptions?.defaultModel
+  });
+  const value = { ai, provider, ...model ? { model } : {} };
+  if (ttl > 0) cache2.set(key, { value, expiresAt: now + ttl });
+  return value;
+}
+
 // src/store/provision.ts
 init_shape();
 async function post(ctx, path, body) {
@@ -1885,6 +1976,9 @@ async function pushAgentSchema(ctx, appId, appKey) {
 async function putSecret(ctx, appId, name, value) {
   await post(ctx, `/admin/apps/${encodeURIComponent(appId)}/secrets`, { name, value });
 }
+async function putRules(ctx, appId, rules) {
+  await post(ctx, `/app/${encodeURIComponent(appId)}/admin/rules`, rules);
+}
 async function provisionAgentApp(opts) {
   const ctx = { endpoint: opts.endpoint, token: opts.token, fetch: opts.fetch };
   const appId = await createApp(ctx, { appId: opts.appId, name: opts.appName });
@@ -1892,6 +1986,9 @@ async function provisionAgentApp(opts) {
   if (opts.pushSchema !== false) {
     await pushAgentSchema({ endpoint: opts.endpoint, fetch: opts.fetch }, appId, appKey);
   }
+  if (opts.rules) {
+    await putRules(ctx, appId, opts.rules);
+  }
   const nameFor = opts.secretName ?? ((p) => DEFAULT_SECRET_NAMES[p]);
   for (const [provider, value] of Object.entries(opts.providerKeys ?? {})) {
     if (!value) continue;