@odla-ai/ai 0.1.4 → 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

@@ -909,6 +909,7 @@ __export(index_exports, {
   blocksOf: () => blocksOf,
   buildCatalog: () => buildCatalog,
   chatCapabilities: () => chatCapabilities,
+  clearPlatformAiCache: () => clearPlatformAiCache,
   clearProviderCache: () => clearProviderCache,
   composeSkills: () => composeSkills,
   createApp: () => createApp,
@@ -922,6 +923,7 @@ __export(index_exports, {
   getProvider: () => getProvider,
   includes: () => includes,
   init: () => init,
+  initFromPlatform: () => initFromPlatform,
   isAudioBlock: () => isAudioBlock,
   isDocumentBlock: () => isDocumentBlock,
   isImageBlock: () => isImageBlock,
@@ -1412,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:
@@ -1848,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;
@@ -1864,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) {