@inneranimalmedia/agentsam-sdk 2.6.4 → 2.6.7

package/packages/agentsam-brand/src/presets/product-shot.json

@@ -0,0 +1,11 @@
+{
+  "id": "product-shot",
+  "label": "Product / UI screenshot",
+  "description": "Preserve raw PNG; optional thumb + marketing widths",
+  "role": "product.raw",
+  "semantic": true,
+  "derivatives": [
+    { "id": "thumb-640", "role": "thumb", "format": "png", "width": 640, "height": 640 },
+    { "id": "card-960", "role": "card", "format": "webp", "width": 960, "height": 960, "quality": 90 }
+  ]
+}

package/packages/agentsam-brand/src/presets/social-image.json

@@ -0,0 +1,10 @@
+{
+  "id": "social-image",
+  "label": "Social media set",
+  "description": "OG/Twitter-oriented 1200×630 raster + web formats",
+  "derivatives": [
+    { "id": "png-1200x630", "role": "raster", "format": "png", "width": 1200, "height": 630 },
+    { "id": "webp-1200x630", "role": "web", "format": "webp", "width": 1200, "height": 630, "quality": 90 },
+    { "id": "avif-1200x630", "role": "web", "format": "avif", "width": 1200, "height": 630, "quality": 75 }
+  ]
+}

package/packages/agentsam-brand/src/presets/web-image.json

@@ -0,0 +1,10 @@
+{
+  "id": "web-image",
+  "label": "Standard web image set",
+  "description": "Primary PNG + WebP + AVIF at source dimensions proxy 1600",
+  "derivatives": [
+    { "id": "png-1600", "role": "raster", "format": "png", "width": 1600, "height": 1600 },
+    { "id": "webp-1600", "role": "web", "format": "webp", "width": 1600, "height": 1600, "quality": 90 },
+    { "id": "avif-1600", "role": "web", "format": "avif", "width": 1600, "height": 1600, "quality": 75 }
+  ]
+}

package/packages/agentsam-contracts/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-contracts",
-  "version": "0.1.0",
-  "private": true,
+  "version": "2.6.7",
   "description": "Framework-neutral AgentSam contracts for workbench, tools, providers, events, hooks, execution, identity and repository context.",
   "type": "module",
   "main": "./src/index.ts",
@@ -28,5 +27,16 @@
   },
   "devDependencies": {
     "typescript": "^5.9.3"
-  }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SamPrimeaux/agentsam-sdk.git",
+    "directory": "packages/agentsam-contracts"
+  },
+  "files": [
+    "src"
+  ]
 }

package/packages/agentsam-contracts/src/artifacts.ts

@@ -12,12 +12,53 @@ export type AgentArtifactKind =
 
 export interface AgentAttachment {
   id: string;
+  /** @deprecated prefer kind — kept for backward compatibility */
   name: string;
   mimeType?: string;
   size?: number;
+  /** @deprecated text-file shortcut — do not use for images */
   text?: string;
   url?: string;
   metadata?: Record<string, unknown>;
+
+  /** Structured multimodal fields (v1+) */
+  kind?:
+    | 'image'
+    | 'document'
+    | 'text'
+    | 'archive'
+    | 'audio'
+    | 'video'
+    | 'model'
+    | 'binary';
+  source?:
+    | { type: 'local_path'; path: string }
+    | { type: 'blob'; blobId: string }
+    | { type: 'url'; url: string }
+    | { type: 'r2'; bucket: string; key: string }
+    | { type: 'artifact'; artifactId: string };
+  sha256?: string;
+  image?: {
+    width: number;
+    height: number;
+    alpha?: boolean;
+    orientation?: number;
+  };
+  preview?: {
+    url?: string;
+    localPath?: string;
+  };
+  inference?: {
+    mimeType: string;
+    source:
+      | { type: 'local_path'; path: string }
+      | { type: 'blob'; blobId: string }
+      | { type: 'url'; url: string };
+    width?: number;
+    height?: number;
+    bytes?: number;
+  };
+  lifetime?: 'ephemeral' | 'conversation' | 'project' | 'artifact' | 'brand';
 }
 
 export interface AgentArtifact {

package/packages/agentsam-contracts/src/tools.ts

@@ -96,3 +96,25 @@ export interface AgentToolCall {
   error?: string;
   metadata?: Record<string, unknown>;
 }
+
+export type AgentToolPermissionDecision = 'allow_once' | 'allow_session' | 'deny';
+
+export interface AgentToolPermissionDatum {
+  label: string;
+  value: string;
+}
+
+export interface AgentToolPermissionRequest {
+  id: string;
+  toolKey: string;
+  displayName: string;
+  provider?: string;
+  summary?: string;
+  scope?: string;
+  sharedData?: AgentToolPermissionDatum[];
+  riskLevel?: AgentToolRiskLevel;
+  sideEffectLevel?: AgentToolSideEffectLevel;
+  destructive?: boolean;
+  openWorld?: boolean;
+  metadata?: Record<string, unknown>;
+}

package/packages/agentsam-errors/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-errors",
-  "version": "0.1.0",
-  "private": true,
+  "version": "2.6.7",
   "description": "Canonical AgentSam runtime error normalization, classification, transport, remediation and rendering.",
   "type": "module",
   "main": "./src/index.js",
@@ -13,5 +12,16 @@
   },
   "engines": {
     "node": ">=22 <25"
-  }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SamPrimeaux/agentsam-sdk.git",
+    "directory": "packages/agentsam-errors"
+  },
+  "files": [
+    "src"
+  ]
 }

package/packages/agentsam-knowledge/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-knowledge",
-  "version": "0.1.0",
-  "private": true,
+  "version": "2.6.7",
   "description": "Portable AutoRAG discovery, adapter registries, probes, and company routing contracts for AgentSam.",
   "type": "module",
   "exports": {
@@ -10,6 +9,21 @@
     "./providers": "./src/providers/index.js",
     "./backends": "./src/backends/index.js"
   },
-  "scripts": { "test": "node --test test/*.test.mjs" },
-  "engines": { "node": ">=22 <25" }
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=22 <25"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SamPrimeaux/agentsam-sdk.git",
+    "directory": "packages/agentsam-knowledge"
+  },
+  "files": [
+    "src"
+  ]
 }

package/packages/agentsam-knowledge/src/autorag/index.js

@@ -6,6 +6,12 @@ import { createBackendRegistry } from '../backends/index.js';
 
 const clean = value => String(value || '').trim();
 const unique = values => [...new Set(values.filter(Boolean))];
+function portableRepositoryIdentity(remote, root) {
+  const value = clean(remote);
+  const github = value.match(/^(?:git@github\.com:|https?:\/\/github\.com\/)([^/]+)\/([^/]+?)(?:\.git)?$/i);
+  if (github) return 'github:' + github[1].toLowerCase() + '/' + github[2].toLowerCase();
+  return value || 'local:' + path.basename(root);
+}
 function git(root, args) { try { return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || null; } catch { return null; } }
 function findScopes(root) {
   const candidates = ['packages', 'src', 'services', 'apps', 'docs', 'README.md', 'schema', 'migrations'];
@@ -13,18 +19,19 @@ function findScopes(root) {
 }
 export async function discoverAutoRag({ root = process.cwd(), env = process.env, companyAdapter = null, fetchImpl } = {}) {
   const isGit = Boolean(git(root, ['rev-parse', '--is-inside-work-tree']));
-  const providerRegistry = createProviderRegistry({ gemini: { apiKey: env.GEMINI_API_KEY, fetchImpl }, openai: { apiKey: env.OPENAI_API_KEY, fetchImpl }, ollama: { endpoint: env.OLLAMA_HOST || 'http://127.0.0.1:11434', fetchImpl } });
+  const providerRegistry = createProviderRegistry({ gemini: { apiKey: env.GEMINI_API_KEY, fetchImpl }, openai: { apiKey: env.OPENAI_API_KEY, fetchImpl }, ollama: { env, fetchImpl } });
   const providers = await providerRegistry.capabilities();
   const docker = git(root, ['--version']) && (() => { try { return Boolean(execFileSync('docker', ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })); } catch { return false; } })();
-  const repositoryId = git(root, ['config', '--get', 'remote.origin.url']) || `local:${path.basename(root)}`;
+  const repositoryId = portableRepositoryIdentity(git(root, ['config', '--get', 'remote.origin.url']), root);
   return Object.freeze({
     repository: { root, name: path.basename(root), identity: repositoryId, branch: git(root, ['branch', '--show-current']), revision: git(root, ['rev-parse', 'HEAD']), git: isGit, merkle: fs.existsSync(path.join(root, '.agentsam', 'merkle.json')), semantic_merkle: fs.existsSync(path.join(root, '.agentsam', 'merkle.json')) },
     scopes: findScopes(root),
-    capabilities: { sqlite: true, git: isGit, merkle: isGit, structural_indexing: true, local_knowledge_engine: true, repository_intelligence: fs.existsSync(path.join(root, 'packages', 'agentsam-repository')), docker, providers, backends: createBackendRegistry().capabilities(), company_graph: Boolean(companyAdapter?.discover) ? await companyAdapter.discover() : { available: false } },
+    capabilities: { sqlite: true, git: isGit, merkle: isGit, structural_indexing: true, local_knowledge_engine: true, repository_intelligence: true, docker, providers, backends: createBackendRegistry().capabilities(), company_graph: Boolean(companyAdapter?.discover) ? await companyAdapter.discover() : { available: false } },
   });
 }
 export function recommendAutoRag({ discovery, purpose = 'code', include, provider = 'none', backend = 'local_exact', semantic = false } = {}) {
-  const scopes = include?.length ? unique(include) : purpose === 'code' ? discovery.scopes.filter(scope => ['packages', 'src'].includes(scope)).slice(0, 2) : discovery.scopes.filter(scope => /^(docs|README\.md|schema|migrations)$/.test(scope)).slice(0, 3);
+  const codeRoots = ['apps', 'src', 'packages', 'services'];
+  const scopes = include?.length ? unique(include) : purpose === 'code' ? codeRoots.filter(scope => discovery.scopes.includes(scope)).slice(0, 3) : discovery.scopes.filter(scope => /^(docs|README\.md|schema|migrations)$/.test(scope)).slice(0, 3);
   return Object.freeze({ purpose, repositories: [discovery.repository.identity], scope: scopes.length ? scopes : ['.'], evidence: purpose === 'code' ? ['git', 'merkle', 'semantic-metadata', 'ast', 'lexical'] : ['git', 'merkle', 'lexical'], embedding: semantic ? provider : 'none', control_plane: 'local_sqlite', backend, probe: { max_files: 25, max_chunks: 100, max_semantic_queries: 1, paid_embeddings: false }, company_registration: 'disabled' });
 }
 export function safeAutoRagConfig({ existing = {}, recommendation, repositoryId, projectKey } = {}) {

package/packages/agentsam-knowledge/src/backends/index.js

@@ -1,8 +1,40 @@
+import { vectorizeDelete, vectorizeGetByIds, vectorizeHealth, vectorizeQuery, vectorizeUpsert } from '../../../connectors/cloudflare/src/families/vectorize.js';
+
 const clean = value => String(value || '').trim();
 function profileGuard(profile, supported) {
   if (!supported.includes(profile?.backend)) throw new Error(`backend_profile_mismatch:${profile?.backend}`);
   if (!Number.isInteger(profile?.dimensions) || profile.dimensions < 1) throw new Error('backend_dimensions_required');
 }
+function vectorizeBackend() {
+  const id = 'cloudflare_vectorize';
+  const resource = context => ({ binding: clean(context?.binding || context?.profile?.binding), index: clean(context?.index || context?.profile?.index) });
+  return Object.freeze({
+    id,
+    capabilities: () => ({ id, explicit_resource_required: true, supported: true, transports: ['worker_binding', 'cloudflare_api'] }),
+    prepare(profile, context = {}) {
+      profileGuard(profile, [id]);
+      const target = { binding: clean(context.binding || profile.binding), index: clean(context.index || profile.index) };
+      if (!target.binding) throw new Error('backend_cloudflare_vectorize_binding_required');
+      if (!target.index) throw new Error('backend_cloudflare_vectorize_index_required');
+      return { id, dimensions: profile.dimensions, ...target };
+    },
+    async upsert(records, context = {}) { return vectorizeUpsert({ ...resource(context), records, context }); },
+    async delete(ids, context = {}) { return vectorizeDelete({ ...resource(context), ids, context }); },
+    async query(vector, options = {}, context = {}) { return vectorizeQuery({ ...resource(context), vector, options, context }); },
+    async verify(ids, context = {}) {
+      const receipt = await vectorizeGetByIds({ ...resource(context), ids, context });
+      const rows = Array.isArray(receipt.result) ? receipt.result : null;
+      return { verified: rows ? rows.length === ids.length : true, transport: receipt.transport, result: receipt.result };
+    },
+    async health(context = {}) {
+      const target = resource(context);
+      if (!target.binding || !target.index) return { id, operational: false, error: 'binding_and_index_required' };
+      const health = await vectorizeHealth({ ...target, context });
+      return { id, ...health };
+    },
+  });
+}
+
 function bindingBackend(id, required) {
   return Object.freeze({
     id, capabilities: () => ({ id, explicit_resource_required: true, supported: true }),
@@ -21,6 +53,6 @@ export function createBackendRegistry() {
     async upsert(records, context = {}) { if (!context.store?.cachePut) throw new Error('backend_runtime_unavailable:local_exact'); for (const record of records) await context.store.cachePut(record.id, record.vector); return { upserted: records.length }; },
     async delete() { return { deleted: 0 }; }, async query() { throw new Error('backend_query_owned_by_knowledge_store'); }, async verify() { return { verified: true }; }, health: async () => ({ id: 'local_exact', operational: true }),
   });
-  const adapters = new Map([['local_exact', local], ['postgres_pgvector', bindingBackend('postgres_pgvector', ['resource'])], ['supabase_pgvector', bindingBackend('supabase_pgvector', ['resource'])], ['cloudflare_vectorize', bindingBackend('cloudflare_vectorize', ['binding', 'index'])]]);
+  const adapters = new Map([['local_exact', local], ['postgres_pgvector', bindingBackend('postgres_pgvector', ['resource'])], ['supabase_pgvector', bindingBackend('supabase_pgvector', ['resource'])], ['cloudflare_vectorize', vectorizeBackend()]]);
   return Object.freeze({ ids: () => [...adapters.keys()], get(id) { const item = adapters.get(clean(id)); if (!item) throw new Error(`backend_unsupported:${id}`); return item; }, capabilities: () => [...adapters.values()].map(adapter => adapter.capabilities()) });
 }

package/packages/agentsam-knowledge/src/providers/index.js

@@ -1,3 +1,4 @@
+import { resolveOllamaEndpoint } from './ollama-endpoint.js';
 const clean = value => String(value || '').trim();
 const finiteVector = (vector, dimensions) => {
   if (!Array.isArray(vector) || vector.length !== dimensions || vector.some(value => typeof value !== 'number' || !Number.isFinite(value))) {
@@ -70,17 +71,18 @@ export function createWorkersAiProvider({ binding } = {}) {
   });
 }
 
-export function createOllamaProvider({ endpoint = process.env.OLLAMA_HOST || 'http://127.0.0.1:11434', fetchImpl = globalThis.fetch, models } = {}) {
+export function createOllamaProvider({ endpoint, env = process.env, fetchImpl = globalThis.fetch, models } = {}) {
   // Model allowlist is advisory only — live `ollama list` / tags are authoritative at selection time.
+  const resolvedEndpoint = resolveOllamaEndpoint({ endpoint, env });
   const known = Array.isArray(models) && models.length ? models : ['mxbai-embed-large', 'nomic-embed-text'];
   return httpAdapter({
     id: 'ollama',
-    env: 'OLLAMA_HOST',
+    env: 'AGENTSAM_OLLAMA_ENDPOINT',
     models: known,
     allowAnyModel: true,
-    credentials: () => endpoint,
+    credentials: () => resolvedEndpoint,
     request: async (text, profile) => {
-      const response = await fetchImpl(new URL('/api/embed', endpoint), {
+      const response = await fetchImpl(new URL('/api/embed', resolvedEndpoint + '/'), {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
         body: JSON.stringify({ model: profile.model, input: text }),

package/packages/agentsam-knowledge/src/providers/ollama-endpoint.js

@@ -0,0 +1,31 @@
+export const OLLAMA_DEFAULT_ENDPOINT = 'http://127.0.0.1:11434';
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+export function normalizeOllamaEndpoint(value = OLLAMA_DEFAULT_ENDPOINT) {
+  let raw = clean(value) || OLLAMA_DEFAULT_ENDPOINT;
+  if (!raw.includes('://')) raw = 'http://' + raw;
+
+  const url = new URL(raw);
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new Error('ollama_endpoint_protocol_invalid:' + url.protocol);
+  }
+
+  if (url.hostname === '0.0.0.0') url.hostname = '127.0.0.1';
+
+  url.pathname = url.pathname.replace(/\/+$/, '') || '/';
+  const normalized = url.toString();
+  return normalized.endsWith('/') ? normalized.slice(0, -1) : normalized;
+}
+
+export function resolveOllamaEndpoint({ endpoint, env = process.env } = {}) {
+  return normalizeOllamaEndpoint(
+    endpoint
+      || env.AGENTSAM_OLLAMA_ENDPOINT
+      || env.OLLAMA_BASE_URL
+      || env.OLLAMA_HOST
+      || OLLAMA_DEFAULT_ENDPOINT,
+  );
+}

package/packages/agentsam-knowledge/test/autorag.test.mjs

@@ -1,6 +1,24 @@
 import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import test from 'node:test';
-import { createFixtureProvider, createProviderRegistry, createBackendRegistry, recommendAutoRag, safeAutoRagConfig, selectIntentRoute, routeCompanyQuestion } from '../src/index.js';
+import { createFixtureProvider, createOllamaProvider, createProviderRegistry, createBackendRegistry, discoverAutoRag, recommendAutoRag, safeAutoRagConfig, selectIntentRoute, routeCompanyQuestion } from '../src/index.js';
+
+
+test('discovery canonicalizes GitHub repository identity and reports SDK repository intelligence', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-autorag-discovery-'));
+  try {
+    execFileSync('git', ['init'], { cwd: root, stdio: 'ignore' });
+    execFileSync('git', ['remote', 'add', 'origin', 'git@github.com:Example/Widget.git'], { cwd: root });
+    const discovery = await discoverAutoRag({ root, env: {} });
+    assert.equal(discovery.repository.identity, 'github:example/widget');
+    assert.equal(discovery.capabilities.repository_intelligence, true);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
 
 test('provider registry is explicit, deterministic, and fails closed', async () => {
   const registry = createProviderRegistry({ fixture: { dimensions: 3 }, gemini: { apiKey: null }, openai: { apiKey: null } });
@@ -12,6 +30,27 @@ test('provider registry is explicit, deterministic, and fails closed', async ()
   assert.equal((await registry.capabilities()).find(item => item.id === 'gemini').operational, false);
 });
 
+test('Ollama provider normalizes bind hosts before issuing embed requests', async () => {
+  let seenUrl = null;
+  const provider = createOllamaProvider({
+    endpoint: '0.0.0.0:11434',
+    fetchImpl: async (url) => {
+      seenUrl = String(url);
+      return new Response(JSON.stringify({ embeddings: [[1, 2, 3]] }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      });
+    },
+  });
+  const vector = await provider.embedQuery('hello', {
+    provider: 'ollama',
+    model: 'mxbai-embed-large',
+    dimensions: 3,
+  });
+  assert.deepEqual(vector, [1, 2, 3]);
+  assert.equal(seenUrl, 'http://127.0.0.1:11434/api/embed');
+});
+
 test('backend registry requires explicit resources and dimensions', () => {
   const registry = createBackendRegistry();
   assert.deepEqual(registry.get('local_exact').prepare({ backend: 'local_exact', dimensions: 3 }), { id: 'local_exact', dimensions: 3 });
@@ -19,6 +58,47 @@ test('backend registry requires explicit resources and dimensions', () => {
   assert.throws(() => registry.get('unknown'), /backend_unsupported/);
 });
 
+test('Cloudflare Vectorize backend executes through Worker binding and user API transports', async () => {
+  const backend = createBackendRegistry().get('cloudflare_vectorize');
+  const profile = { backend: 'cloudflare_vectorize', dimensions: 3, binding: 'MY_VECTORS', index: 'customer-code-index' };
+  assert.deepEqual(backend.prepare(profile), { id: 'cloudflare_vectorize', dimensions: 3, binding: 'MY_VECTORS', index: 'customer-code-index' });
+
+  const workerCalls = [];
+  const workerBinding = {
+    async upsert(records) { workerCalls.push(['upsert', records]); return { mutationId: 'm1' }; },
+    async query(vector, options) { workerCalls.push(['query', vector, options]); return { matches: [{ id: 'one', score: 0.9 }] }; },
+    async deleteByIds(ids) { workerCalls.push(['delete', ids]); return { mutationId: 'm2' }; },
+    async getByIds(ids) { workerCalls.push(['get', ids]); return ids.map(id => ({ id })); },
+  };
+  const workerContext = { binding: 'MY_VECTORS', index: 'customer-code-index', env: { MY_VECTORS: workerBinding } };
+  assert.equal((await backend.upsert([{ id: 'one', vector: [1, 0, 0], metadata: { path: 'apps/a.js' } }], workerContext)).transport, 'worker_binding');
+  assert.equal((await backend.query([1, 0, 0], { topK: 3 }, workerContext)).transport, 'worker_binding');
+  assert.equal((await backend.delete(['one'], workerContext)).transport, 'worker_binding');
+  assert.equal((await backend.verify(['one'], workerContext)).verified, true);
+  assert.deepEqual(workerCalls.map(row => row[0]), ['upsert', 'query', 'delete', 'get']);
+
+  const apiCalls = [];
+  const apiClient = {
+    accountPath(suffix) { return `/accounts/acct${suffix}`; },
+    async request(method, requestPath, options) {
+      apiCalls.push({ method, requestPath, options });
+      if (requestPath.endsWith('/get_by_ids')) return { result: [{ id: 'one' }], auth: { source: 'fixture' } };
+      return { result: { ok: true }, auth: { source: 'fixture' } };
+    },
+  };
+  const apiContext = { binding: 'MY_VECTORS', index: 'customer-code-index', apiClient };
+  assert.equal((await backend.upsert([{ id: 'one', vector: [1, 0, 0] }], apiContext)).transport, 'cloudflare_api');
+  assert.equal((await backend.query([1, 0, 0], { topK: 2 }, apiContext)).transport, 'cloudflare_api');
+  assert.equal((await backend.delete(['one'], apiContext)).transport, 'cloudflare_api');
+  assert.equal((await backend.verify(['one'], apiContext)).verified, true);
+  assert.equal(apiCalls[0].requestPath, '/accounts/acct/vectorize/v2/indexes/customer-code-index/upsert');
+  assert.equal(apiCalls[0].options.headers['Content-Type'], 'application/x-ndjson');
+  assert.match(apiCalls[0].options.body, /\"id\":\"one\"/);
+  assert.equal(apiCalls[1].requestPath, '/accounts/acct/vectorize/v2/indexes/customer-code-index/query');
+  assert.equal(apiCalls[2].requestPath, '/accounts/acct/vectorize/v2/indexes/customer-code-index/delete_by_ids');
+  assert.equal(apiCalls[3].requestPath, '/accounts/acct/vectorize/v2/indexes/customer-code-index/get_by_ids');
+});
+
 test('recommendation preserves local defaults and never serializes credentials', () => {
   const discovery = { repository: { identity: 'local:demo' }, scopes: ['src', 'docs'] };
   const recommendation = recommendAutoRag({ discovery, purpose: 'code' });

package/packages/agentsam-nav/package.json

@@ -1,18 +1,31 @@
 {
   "name": "@inneranimalmedia/agentsam-nav",
-  "version": "0.1.0",
+  "version": "2.6.7",
   "private": false,
   "description": "Reusable responsive navigation primitives for AgentSam dashboard-family applications.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist", "README.md"],
-  "sideEffects": ["**/*.css"],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
   "license": "MIT",
-  "publishConfig": { "access": "public" },
+  "publishConfig": {
+    "access": "public"
+  },
   "exports": {
-    ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" },
-    "./browser": { "types": "./dist/browser.d.ts", "import": "./dist/browser.js" },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
     "./browser.global.js": "./dist/browser.global.js",
     "./theme.css": "./dist/theme.css",
     "./legacy.css": "./dist/legacy.css"
@@ -28,8 +41,8 @@
     "react-dom": ">=18"
   },
   "devDependencies": {
-    "@types/react": "^19.2.0",
-    "@types/react-dom": "^19.2.0",
+    "@types/react": "19.2.18",
+    "@types/react-dom": "19.2.3",
     "esbuild": "^0.28.1",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
@@ -39,5 +52,10 @@
     "@radix-ui/react-dialog": "^1.1.23",
     "@radix-ui/react-dropdown-menu": "^2.1.24",
     "lucide-react": "^0.510.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SamPrimeaux/agentsam-sdk.git",
+    "directory": "packages/agentsam-nav"
   }
 }

package/packages/agentsam-queue-control/README.md

@@ -100,7 +100,7 @@ Dispatch supports exact kinds and prefix wildcards such as `cad.*`.
 
 ## Relationship to WorkGraph
 
-Queue Control does not replace `@inneranimalmedia/work-graph`. A WorkGraph can release ready nodes; Queue Control then schedules those nodes to an executor. Completion receipts can be projected back into the graph by the host.
+Queue Control does not replace `@inneranimalmedia/agentsam-work-graph`. A WorkGraph can release ready nodes; Queue Control then schedules those nodes to an executor. Completion receipts can be projected back into the graph by the host.
 
 ## Relationship to AgentSam tools and MCP
 

package/packages/agentsam-queue-control/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-queue-control",
-  "version": "0.1.0",
+  "version": "2.6.7",
   "description": "Portable AgentSam queue, job-routing, batching, and execution-control primitives with Cloudflare-first adapters.",
   "type": "module",
   "main": "./src/index.js",
@@ -27,5 +27,10 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SamPrimeaux/agentsam-sdk.git",
+    "directory": "packages/agentsam-queue-control"
+  }
 }