@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.4

package/src/go/official-release.js

@@ -0,0 +1,10 @@
+export const INNERANIMALMEDIA_OFFICIAL_RELEASE_ENV =
+  'AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE';
+
+export const LEGACY_IAM_OFFICIAL_RELEASE_ENV =
+  'AGENTSAM_IAM_OFFICIAL_RELEASE';
+
+export function innerAnimalMediaOfficialReleaseEnabled(env = process.env) {
+  return env?.[INNERANIMALMEDIA_OFFICIAL_RELEASE_ENV] === '1'
+    || env?.[LEGACY_IAM_OFFICIAL_RELEASE_ENV] === '1';
+}

package/src/go/receipts.js

@@ -10,18 +10,40 @@ export function goStateDir(productRoot) {
 export function writeGoBuildReceipt(productRoot, receipt) {
   const dir = goStateDir(productRoot);
   const file = path.join(dir, 'latest.build-receipt.json');
-  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  fs.writeFileSync(file, JSON.stringify(receipt, null, 2) + '\n');
   return file;
 }
 
 export function writeDeploymentReceipt(productRoot, receipt) {
   const dir = goStateDir(productRoot);
   const file = path.join(dir, 'latest.deployment-receipt.json');
+  const payload = { schema: 'agentsam.deployment-receipt.v1', ...receipt };
+  fs.writeFileSync(file, JSON.stringify(payload, null, 2) + '\n');
+  return file;
+}
+
+export function writeDeploymentValidationReceipt(productRoot, receipt) {
+  const dir = goStateDir(productRoot);
+  const file = path.join(dir, 'latest.deployment-validation-receipt.json');
   const payload = {
-    schema: 'agentsam.deployment-receipt.v1',
+    schema: 'agentsam.deployment-validation-receipt.v1',
     ...receipt,
   };
-  fs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`);
+  fs.writeFileSync(file, JSON.stringify(payload, null, 2) + '\n');
+  return file;
+}
+
+export function writeProductValidationLocal(productRoot, row) {
+  const dir = goStateDir(productRoot);
+  const file = path.join(dir, 'product.validation-registry.json');
+  const payload = {
+    schema: 'agentsam.product-validation-registry.v1',
+    registry: 'agentsam_products',
+    authority: 'local_validation',
+    row,
+    written_at: new Date().toISOString(),
+  };
+  fs.writeFileSync(file, JSON.stringify(payload, null, 2) + '\n');
   return file;
 }
 
@@ -31,11 +53,11 @@ export function writeProductRegistryLocal(productRoot, row) {
   const payload = {
     schema: 'agentsam.product-local-registry.v1',
     registry: 'agentsam_products',
-    note: 'Local projection + optional remote D1 upsert into agentsam_products / asset_relationships.',
+    note: 'Local AgentSam projection. InnerAnimalMedia D1 registration is a separate explicit official-release operation.',
     row,
     written_at: new Date().toISOString(),
   };
-  fs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`);
+  fs.writeFileSync(file, JSON.stringify(payload, null, 2) + '\n');
   return file;
 }
 
@@ -44,20 +66,43 @@ export function readLatestStatus(productRoot) {
   const buildPath = path.join(dir, 'latest.build-receipt.json');
   const deployPath = path.join(dir, 'latest.deployment-receipt.json');
   const productPath = path.join(dir, 'product.registry.json');
+  const validationPath = path.join(dir, 'latest.deployment-validation-receipt.json');
+  const validationProductPath = path.join(dir, 'product.validation-registry.json');
   return {
     build: fs.existsSync(buildPath) ? JSON.parse(fs.readFileSync(buildPath, 'utf8')) : null,
     deployment: fs.existsSync(deployPath) ? JSON.parse(fs.readFileSync(deployPath, 'utf8')) : null,
     product: fs.existsSync(productPath) ? JSON.parse(fs.readFileSync(productPath, 'utf8')) : null,
+    validation: fs.existsSync(validationPath) ? JSON.parse(fs.readFileSync(validationPath, 'utf8')) : null,
+    validation_product: fs.existsSync(validationProductPath)
+      ? JSON.parse(fs.readFileSync(validationProductPath, 'utf8'))
+      : null,
   };
 }
 
-export function buildProductRow({ product, repositoryId, commit, url, health }) {
+export function buildProductRow({
+  product,
+  repositoryId,
+  commit,
+  sourceIdentity = null,
+  packageName = '@inneranimalmedia/agentsam-go-worker',
+  packageVersion = '0.1.0',
+  cloudflareAccount = null,
+  url,
+  health,
+  workerDeploymentId = null,
+  workerVersionId = null,
+  artifactDigest = null,
+  containerDigest = null,
+}) {
   return {
     slug: product,
     kind: 'service',
     name: product,
     status: health === 'healthy' ? 'deployed' : (health === 'pending' ? 'built' : 'degraded'),
     repository_id: repositoryId || null,
+    canonical_path: 'apps/agentsam-go-worker',
+    package_name: packageName,
+    version: packageVersion,
     metadata: {
       runtime: 'go',
       deployment: {
@@ -65,12 +110,34 @@ export function buildProductRow({ product, repositoryId, commit, url, health })
         mode: 'worker-container',
         url: url || null,
         health: health || null,
+        worker_deployment_id: workerDeploymentId,
+        worker_version_id: workerVersionId,
+        artifact_digest: artifactDigest,
+        container_image_digest: containerDigest,
+        cloudflare_account: cloudflareAccount,
+      },
+      source: {
+        identity: sourceIdentity,
+        commit: commit || null,
+        package_name: packageName,
+        package_version: packageVersion,
       },
-      source: { commit: commit || null },
       relationships: [
-        { type: 'source_repository', target: repositoryId || null },
-        { type: 'runtime', target: 'go' },
-        { type: 'edge', target: 'cloudflare-worker' },
+        repositoryId
+          ? { type: 'source_repository', target: repositoryId }
+          : { type: 'source_package', target: packageName },
+        {
+          type: 'runtime',
+          target: 'go',
+          target_type: 'runtime',
+          relationship_type: 'runs_on',
+        },
+        {
+          type: 'edge',
+          target: product,
+          target_type: 'cloudflare_worker',
+          relationship_type: 'deployed_as',
+        },
       ],
     },
   };

package/src/go/verify.js

@@ -4,18 +4,25 @@ import { runGoTests, runGoVet } from './build.js';
 
 export async function verifyGoProduct({
   productRoot,
+  stateRoot = productRoot,
   runtimeRoot,
   url = null,
   fetchImpl = globalThis.fetch,
   skipLive = false,
 } = {}) {
-  const status = readLatestStatus(productRoot);
+  const status = readLatestStatus(stateRoot);
   const tests = runtimeRoot ? runGoTests(runtimeRoot) : { ok: false, error: 'no_runtime' };
   const vet = runtimeRoot ? runGoVet(runtimeRoot) : { ok: false, error: 'no_runtime' };
   const liveUrl = url || status.deployment?.url || null;
   let live = { skipped: true, ok: false };
   if (!skipLive && liveUrl) {
-    live = await probeGoDeployment(liveUrl, { fetchImpl });
+    live = await probeGoDeployment(liveUrl, {
+      fetchImpl,
+      expectedSource: status.deployment?.source_identity || status.build?.source?.identity || null,
+      expectedSourceCommit: status.deployment?.source_commit || status.build?.source?.commit || null,
+      expectedTarget: 'cloudflare',
+      edge: true,
+    });
   }
 
   const ok = Boolean(tests.ok && vet.ok && (skipLive || !liveUrl || live.ok));

package/src/index.js

@@ -3,6 +3,27 @@
 import pkg from '../package.json' with { type: 'json' };
 
 export { AgentSam } from './AgentSam.js';
+export {
+  SAM_RESULT_SCHEMA,
+  SAM_EXPANSION,
+  defineSamOperation,
+  registerSamOperation,
+  getSamOperation,
+  listSamOperations,
+  toSamOperationCard,
+  buildSamResult,
+  AgentSamClient,
+  createAgentSamClient,
+  ensureSeedOperations,
+  SEED_OPERATIONS,
+} from './sam/index.js';
+export {
+  CLI_COMMAND_CATALOG,
+  getCliCommand,
+  listCliCommands,
+  printAssistTip,
+  suggestCliCommands,
+} from './cli/command-catalog.js';
 export { routeIntent } from './lib/router.js';
 export { searchToolCards, toToolCard, hydrateToolSchemas } from './tools/index.js';
 export {
@@ -130,6 +151,12 @@ export {
   fingerprintError,
   shouldRetry,
   retryDelayMs,
+  planRecovery,
+  inferFailureClass,
+  inferSideEffectState,
+  FAILURE_CLASS,
+  SIDE_EFFECT_STATE,
+  RECOVERY_SCHEMA,
   toHttpError,
   fromHttpError,
   renderError,

package/src/indexing/ingest/discover-models.js

@@ -0,0 +1,298 @@
+/**
+ * Discover embedding models from the user's configured credentials.
+ *
+ * Authority order for the picker:
+ *   1. Credential-scoped cloud providers (OpenAI, Gemini, Cloudflare Workers AI)
+ *   2. Optional local Ollama inventory (offer only — never required, never SSOT)
+ *   3. Always "none" (AST/text only)
+ *
+ * Dimensions are profile fingerprints for the chosen provider/model — not "Ollama truth."
+ * Regex/name heuristics are hints until a real embed/adapter reports length.
+ */
+
+import { collectModelsStatus } from '../../commands/models.js';
+import { resolveOllamaConfig, probeOllama, probeOllamaModel } from '../../commands/ollama.js';
+import { resolveProviderCredential } from '../../lib/provider-credentials.js';
+import { createProviderRegistry } from '../../../packages/agentsam-knowledge/src/providers/index.js';
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+/** Known Workers AI / Vectorize-friendly embed dims (hint until first embed probes). */
+const WORKERS_AI_EMBED_DIMS = Object.freeze({
+  '@cf/baai/bge-small-en-v1.5': 384,
+  '@cf/baai/bge-base-en-v1.5': 768,
+  '@cf/baai/bge-large-en-v1.5': 1024,
+  '@cf/baai/bge-m3': 1024,
+  '@cf/google/embeddinggemma-300m': 768,
+});
+
+function looksLikeEmbedModel(name) {
+  const id = clean(name).toLowerCase();
+  if (!id) return false;
+  return /embed|bge-|e5-|gte-|minilm|mxbai-embed|nomic-embed|snowflake-arctic-embed/i.test(id);
+}
+
+/**
+ * Hint dimensions for a provider/model. Not authoritative — adapters may probe.
+ */
+function defaultDimensions(provider, model) {
+  const id = clean(model).toLowerCase();
+  if (provider === 'openai') {
+    if (id.includes('large')) return 3072;
+    if (id.includes('small')) return 1536;
+    return 1536;
+  }
+  if (provider === 'gemini') {
+    return 768;
+  }
+  if (provider === 'workers-ai' || provider === 'cloudflare') {
+    if (WORKERS_AI_EMBED_DIMS[clean(model)]) return WORKERS_AI_EMBED_DIMS[clean(model)];
+    if (id.includes('small')) return 384;
+    if (id.includes('large') || id.includes('bge-m3')) return 1024;
+    return 768;
+  }
+  if (provider === 'ollama') {
+    if (id.includes('mxbai-embed-large')) return 1024;
+    if (id.includes('nomic-embed')) return 768;
+    return 1024;
+  }
+  return 768;
+}
+
+/**
+ * Encode a selectable embedding profile for clack / CLI.
+ * Format: provider|model|dimensions  (pipe — models may contain colons)
+ */
+export function encodeEmbeddingChoice(provider, model, dimensions) {
+  return `${provider}|${model}|${dimensions}`;
+}
+
+/**
+ * @param {string} value
+ */
+export function parseEmbeddingChoice(value) {
+  if (!value || value === 'none') {
+    return { provider: 'none', model: 'none', revision: '1', dimensions: 0, parameters: {} };
+  }
+  // New encoding: provider|model|dims
+  if (String(value).includes('|')) {
+    const [provider, model, dims] = String(value).split('|');
+    return {
+      provider: clean(provider),
+      model: clean(model),
+      revision: '1',
+      dimensions: Number(dims) || defaultDimensions(provider, model),
+      parameters: provider === 'gemini' ? { task: 'code retrieval' } : {},
+    };
+  }
+  // Legacy encoding used briefly: provider:model:dims (breaks on model ids with colons)
+  const parts = String(value).split(':');
+  if (parts.length >= 3) {
+    const provider = parts[0];
+    const dims = parts[parts.length - 1];
+    const model = parts.slice(1, -1).join(':');
+    return {
+      provider: clean(provider),
+      model: clean(model),
+      revision: '1',
+      dimensions: Number(dims) || defaultDimensions(provider, model),
+      parameters: provider === 'gemini' ? { task: 'code retrieval' } : {},
+    };
+  }
+  throw new Error(`invalid_embedding_choice:${value}`);
+}
+
+/**
+ * Build embedding select options from live discovery.
+ * Always offers "none" (AST/text only). Ollama entries appear only when online (optional).
+ *
+ * @param {object} [options]
+ * @returns {Promise<{ options: object[], inventory: object, assistModels: object[] }>}
+ */
+export async function discoverIngestModelOptions(options = {}) {
+  const env = options.env || process.env;
+  const status = await collectModelsStatus({
+    env,
+    home: options.home,
+    discoverRemote: options.discoverRemote !== false,
+    includeLocal: true,
+    // Keep CF embed models; chat allowlist must not hide Vectorize options.
+    curateWorkersAi: options.curateWorkersAi !== false,
+    fetchImpl: options.fetchImpl,
+    providerFetchImpl: options.providerFetchImpl,
+  });
+
+  /** @type {Map<string, object>} */
+  const byValue = new Map();
+  const push = (row) => {
+    if (!row?.value || byValue.has(row.value)) return;
+    byValue.set(row.value, row);
+  };
+
+  push({
+    value: 'none',
+    label: 'None — AST/text only ($0 embeddings)',
+    hint: 'deterministic · no provider spend',
+    provider: 'none',
+    source: 'builtin',
+  });
+
+  // Credential-scoped OpenAI embedding models from live /v1/models
+  for (const row of status.providerModels?.openai || []) {
+    const caps = row.capabilities || {};
+    const id = row.provider_model_id || '';
+    if (caps.embeddings === true || /^text-embedding-/i.test(id)) {
+      const dims = defaultDimensions('openai', id);
+      push({
+        value: encodeEmbeddingChoice('openai', id, dims),
+        label: `OpenAI · ${id}`,
+        hint: `credential · ${dims}d`,
+        provider: 'openai',
+        source: 'provider_api',
+        model: id,
+        dimensions: dims,
+      });
+    }
+  }
+
+  // Gemini: if key configured, offer models from knowledge adapter + any discovered embed ids
+  const geminiCred = resolveProviderCredential('gemini', { env, home: options.home });
+  if (geminiCred?.configured) {
+    const registry = createProviderRegistry({
+      gemini: { apiKey: geminiCred.value || env.GEMINI_API_KEY },
+    });
+    const caps = registry.get('gemini').capabilities();
+    for (const id of caps.models || []) {
+      const dims = defaultDimensions('gemini', id);
+      push({
+        value: encodeEmbeddingChoice('gemini', id, dims),
+        label: `Gemini · ${id}`,
+        hint: `credential · ${dims}d`,
+        provider: 'gemini',
+        source: 'provider_credential',
+        model: id,
+        dimensions: dims,
+      });
+    }
+  }
+
+  // Cloudflare Workers AI embedding models — required for Vectorize / CF lanes.
+  // Uses live account discovery (Text Embeddings). Provider id = workers-ai (knowledge adapter).
+  for (const row of status.providerModels?.cloudflare || []) {
+    const caps = row.capabilities || {};
+    const id = row.provider_model_id || '';
+    const task = String(row.metadata?.task || '').toLowerCase();
+    const isEmbed = caps.embeddings === true || task === 'text embeddings' || looksLikeEmbedModel(id);
+    if (!isEmbed || !id) continue;
+    const dims = defaultDimensions('workers-ai', id);
+    push({
+      value: encodeEmbeddingChoice('workers-ai', id, dims),
+      label: `Workers AI · ${id}`,
+      hint: `cloudflare · vectorize-ready · ${dims}d`,
+      provider: 'workers-ai',
+      source: 'provider_api',
+      model: id,
+      dimensions: dims,
+    });
+  }
+
+  // Optional local Ollama — never required; only offered when online.
+  /** @type {object[]} */
+  const assistModels = [];
+  if (status.local?.online) {
+    const ollamaConfig = resolveOllamaConfig({}, env);
+    for (const row of status.local.models || []) {
+      const name = clean(row.name || row.model);
+      if (!name) continue;
+      const probe = options.skipOllamaProbe
+        ? { ok: true, capabilities: [] }
+        : await probeOllamaModel(name, ollamaConfig, options.fetchImpl || fetch);
+      const caps = Array.isArray(probe.capabilities) ? probe.capabilities : [];
+      const isEmbed = looksLikeEmbedModel(name) || caps.includes('embedding') || caps.includes('embed');
+      if (isEmbed) {
+        // Prefer probed dim length when the adapter returns it; else name hint.
+        const probedDims = Number(probe.dimensions) || Number(probe.embedding_length) || 0;
+        const dims = probedDims > 0 ? probedDims : defaultDimensions('ollama', name);
+        push({
+          value: encodeEmbeddingChoice('ollama', name, dims),
+          label: `Ollama · ${name}`,
+          hint: `local optional · ${dims}d`,
+          provider: 'ollama',
+          source: 'ollama_tags',
+          model: name,
+          dimensions: dims,
+        });
+      } else {
+        assistModels.push({
+          value: `ollama|${name}`,
+          label: `Ollama · ${name}`,
+          hint: 'local assist (allowlist suggestions)',
+          provider: 'ollama',
+          model: name,
+          source: 'ollama_tags',
+        });
+      }
+    }
+  }
+
+  return {
+    options: [...byValue.values()],
+    inventory: status,
+    assistModels,
+    ollama: status.local,
+  };
+}
+
+/**
+ * Ask a local Ollama chat model to suggest include/exclude paths.
+ * Optional — never required for ingest.
+ *
+ * @param {{ root: string, model: string, topLevel: string[], fetchImpl?: typeof fetch, env?: object }} opts
+ */
+export async function suggestScopeWithLocalModel(opts) {
+  const env = opts.env || process.env;
+  const config = resolveOllamaConfig({}, env);
+  const endpoint = new URL('/api/generate', config.baseUrl);
+  const listing = (opts.topLevel || []).slice(0, 80).join('\n');
+  const prompt = [
+    'You help configure a repository knowledge allowlist/denylist for AgentSam codebaseindex.',
+    'Return ONLY compact JSON: {"include":["..."],"exclude":["..."],"rationale":"..."}',
+    'include/exclude must be relative path segments (no globs). Prefer source dirs; exclude deps/build caches.',
+    'Machine inventory already classified top-level paths — prefer refining those categories, do not invent unrelated roots.',
+    `Repository root: ${opts.root}`,
+    opts.categories ? `Categories JSON: ${JSON.stringify(opts.categories)}` : '',
+    'Top-level entries:',
+    listing || '(empty)',
+  ].filter(Boolean).join('\n');
+
+  const response = await (opts.fetchImpl || fetch)(endpoint, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ model: opts.model, prompt, stream: false, format: 'json' }),
+    signal: AbortSignal.timeout(60_000),
+  });
+  if (!response.ok) {
+    throw new Error(`ollama_assist_failed:HTTP ${response.status}`);
+  }
+  const body = await response.json();
+  const raw = clean(body?.response);
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error('ollama_assist_invalid_json');
+  }
+  const include = Array.isArray(parsed.include) ? parsed.include.map(clean).filter(Boolean) : [];
+  const exclude = Array.isArray(parsed.exclude) ? parsed.exclude.map(clean).filter(Boolean) : [];
+  return {
+    include,
+    exclude,
+    rationale: clean(parsed.rationale) || null,
+    model: opts.model,
+    provider: 'ollama',
+  };
+}
+
+export { probeOllama, resolveOllamaConfig, looksLikeEmbedModel, defaultDimensions, WORKERS_AI_EMBED_DIMS };