@inneranimalmedia/agentsam-sdk 2.6.9 → 2.6.10

package/src/errors/diagnostic.js

@@ -181,16 +181,16 @@ export function diagnosticFromError(error, fallback = {}) {
   if (error?.diagnostic) return error.diagnostic;
   const envelope = error?.envelope || (error?.ok === false && error?.schema_version ? error : null);
   if (envelope) return legacyDiagnosticFromEnvelope(envelope, fallback);
-  return Object.freeze({
-    schema_version: 1,
-    source: fallback.source || 'agentsam',
-    kind: fallback.kind || 'runtime_error',
-    code: clean(error?.code || fallback.code) || 'runtime_error',
-    message: redactString(error?.message || error || fallback.message || 'Unknown error', 4_000),
-    http_status: Number(error?.status || fallback.status || 0) || null,
-    retriable: Boolean(fallback.retriable),
-    retry_strategy: fallback.retry_strategy || 'inspect_error',
+  const canonical = normalizeError(error, {
+    reason: fallback.reason,
+    domain: fallback.domain || 'runtime',
+    stage: fallback.stage,
+    feature: fallback.feature,
+    failure_behavior: fallback.failure_behavior,
+    side_effect_state: fallback.side_effect_state,
+    source: { kind: 'runtime', name: fallback.source || 'agentsam-sdk' },
   });
+  return legacyDiagnosticFromEnvelope(canonical, fallback);
 }
 
 export function renderDiagnosticError(error) {

package/src/index.js

@@ -25,6 +25,37 @@ export {
   suggestCliCommands,
 } from './cli/command-catalog.js';
 export { routeIntent } from './lib/router.js';
+export {
+  HOOK_PROTOCOL_SCHEMA,
+  HOOK_CONFIG_SCHEMA,
+  HOOK_RECEIPT_SCHEMA,
+  HOOK_EVENTS,
+  PERMISSION_DECISIONS,
+  ERROR_HANDLING_DECISIONS,
+  HOOK_FAILURE_MODES,
+  AgentSamHooks,
+  HookExecutionError,
+  HookPermissionError,
+  normalizeHookEvent,
+  normalizeHookOutput,
+  createHookEnvelope,
+  createHookRuntime,
+  createHookRuntimeFromConfig,
+  createHookStore,
+  registerStoredHooks,
+  ensureHookRuntime,
+  findHookConfig,
+  loadHookConfig,
+  createCallbackHookAdapter,
+  createCommandHookAdapter,
+  createHttpHookAdapter,
+  createHookedProviderAdapter,
+  createHookedCapabilityAdapter,
+  createCompositeCapabilityAdapter,
+  createMcpCapabilityAdapter,
+  createLspCapabilityAdapter,
+  createAgentCapabilityAdapter,
+} from '../packages/agentsam-hooks/src/index.js';
 export { searchToolCards, toToolCard, hydrateToolSchemas } from './tools/index.js';
 export {
   AGENTSAM_PLUGIN_SCHEMA_VERSION,
@@ -36,6 +67,7 @@ export {
   listPlugins,
   listPluginTools,
   recordPluginHealthCheck,
+  recordAiPluginModelDiscovery,
   recordToolCall,
   createPluginRuntime,
   createPluginCapabilityAdapter,

package/src/knowledge/service/grpc-codec.js

@@ -77,6 +77,7 @@ export function encodeErrorDetail(value) {
   detail.setDomain(envelope.domain);
   if (envelope.tool) detail.setTool(envelope.tool);
   if (envelope.stage) detail.setStage(envelope.stage);
+  if (envelope.native_stage) detail.setNativeStage(envelope.native_stage);
   detail.setRemediationAction(envelope.remediation.action);
   if (envelope.remediation.message) detail.setRemediationMessage(envelope.remediation.message);
   detail.setFingerprint(envelope.fingerprint);
@@ -115,6 +116,7 @@ export function decodeErrorDetail(detail) {
     domain: detail.hasDomain?.() ? detail.getDomain() : 'runtime',
     tool: detail.hasTool?.() ? detail.getTool() : null,
     stage: detail.hasStage?.() ? detail.getStage() : null,
+    native_stage: detail.hasNativeStage?.() ? detail.getNativeStage() : null,
     remediation: {
       action: detail.hasRemediationAction?.() ? detail.getRemediationAction() : undefined,
       message: detail.hasRemediationMessage?.() ? detail.getRemediationMessage() : null,

package/src/lib/slash-commands.js

@@ -12,6 +12,7 @@ export const SLASH_COMMANDS = [
   { cmd: '/context', description: 'Show model context economics; add repo for Git bridge context', lane: 'context' },
   { cmd: '/status', description: 'Honest project awareness: account, models, terminal, live deploy', lane: 'local' },
   { cmd: '/models', description: 'Probe providers and provider-verified known models', lane: 'model' },
+  { cmd: '/hooks', description: 'Inspect lifecycle hook sources, order, and execution receipts', lane: 'agent' },
   { cmd: '/providers', description: 'Configure and verify machine provider credentials', lane: 'model' },
   { cmd: '/credentials', description: 'Audit credentials, drift, and remediation (never prints secrets)', lane: 'identity' },
   { cmd: '/cheat-sheet', description: 'Organized Agent Sam command groups', lane: 'local' },

package/src/local/runtime-store.js

@@ -4,6 +4,7 @@ import { createLocalSqliteDatabase } from './sqlite.js';
 import { applyRuntimeMigrations } from './migrations.js';
 import { findCliProjectRoot } from '../lib/cli-preferences.js';
 import { getLocalDatabasePath, tryReadProjectConfig } from '../lib/project-config.js';
+import { createHookStore } from '../../packages/agentsam-hooks/src/store.js';
 
 function clean(value) { return value == null ? '' : String(value).trim(); }
 function hash(value) { return createHash('sha256').update(String(value || '')).digest('hex'); }
@@ -187,3 +188,48 @@ export async function pruneExpiredRuntimeState(value = {}) {
     return { digests: Number(digests.changes || 0), compactions: Number(compactions.changes || 0), approvals_expired: Number(approvals.changes || 0) };
   });
 }
+
+function hookStore(db, value = {}) {
+  return createHookStore(db, { ownerId: clean(value.owner_id || value.account_id) || 'local' });
+}
+
+export async function listRuntimeHooks(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).listHooks({
+    activeOnly: value.activeOnly,
+    event_type: value.event_type,
+    context: value.context,
+  }));
+}
+
+export async function upsertRuntimeHook(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).upsertHook(value));
+}
+
+export async function setRuntimeHookActive(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).setHookActive(value.hook_id || value.hook_key, value.active));
+}
+
+export async function removeRuntimeHook(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).removeHook(value.hook_id || value.hook_key));
+}
+
+export async function recordRuntimeHookReceipt(value = {}) {
+  if (!value.receipt) return null;
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).recordExecution(value.receipt, {
+    source_kind: value.source_kind,
+    hook_id: value.hook_id,
+    invocation_id: value.invocation_id,
+    agent_run_id: value.agent_run_id,
+    session_id: value.session_id,
+    conversation_id: value.conversation_id,
+    context: value.context,
+  }));
+}
+
+export async function listRuntimeHookExecutions(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).listExecutions({
+    hook_key: value.hook_key,
+    status: value.status,
+    limit: value.limit,
+  }));
+}

package/src/models/catalog.js

@@ -7,7 +7,6 @@ const DOCS = Object.freeze({
   gpt56Sol: 'https://developers.openai.com/api/docs/models/gpt-5.6-sol',
   gpt56Terra: 'https://developers.openai.com/api/docs/models/gpt-5.6-terra',
   gpt56Luna: 'https://developers.openai.com/api/docs/models/gpt-5.6-luna',
-  gpt53Codex: 'https://developers.openai.com/api/docs/models/gpt-5.3-codex',
   embeddingLarge: 'https://developers.openai.com/api/docs/models/text-embedding-3-large',
   embeddingSmall: 'https://developers.openai.com/api/docs/models/text-embedding-3-small',
 });
@@ -226,53 +225,6 @@ const GPT_56_LUNA = openAiAgentModel({
   pricing: freezePricing({ input: 0.2, cachedInput: 0.02, cacheWrite: 0.25, output: 1.2, source: DOCS.gpt56Luna }),
 });
 
-const GPT_53_CODEX = openAiAgentModel({
-  id: 'gpt-5.3-codex',
-  label: 'GPT-5.3-Codex',
-  source: DOCS.gpt53Codex,
-  reasoning: ['low', 'medium', 'high', 'xhigh'],
-  contextWindow: 400_000,
-  maxOutputTokens: 128_000,
-  knowledgeCutoff: '2025-08-31',
-  description: 'Agentic coding model for Codex-style software workflows.',
-  pricing: freezePricing({
-    input: 1.75,
-    cachedInput: 0.175,
-    cacheWrite: 0,
-    output: 14,
-    source: DOCS.gpt53Codex,
-    longContext: false,
-    processing: false,
-  }),
-  capabilities: {
-    web_search: false,
-    file_search: false,
-    image_generation: false,
-    code_interpreter: false,
-    hosted_shell: false,
-    apply_patch: false,
-    skills: false,
-    computer_use: false,
-    mcp: false,
-    tool_search: false,
-    async_tool_calls: false,
-    mid_turn_steering: false,
-    configuration_update: false,
-    fast: false,
-    flex: false,
-  },
-  serviceTiers: ['default'],
-  contextPolicy: Object.freeze({
-    target_input_tokens: 100_000,
-    compact_at_tokens: 160_000,
-    intervene_at_tokens: 210_000,
-    max_normal_input_tokens: 240_000,
-    pricing_threshold_tokens: null,
-    max_cumulative_input_tokens: 400_000,
-    safety_margin_tokens: 20_000,
-  }),
-});
-
 const TEXT_EMBEDDING_3_LARGE = openAiEmbeddingModel({
   id: 'text-embedding-3-large',
   label: 'text-embedding-3-large',
@@ -296,7 +248,6 @@ export const MODEL_CATALOG = Object.freeze([
   GPT_56_LUNA,
   GPT_56_TERRA,
   GPT_56_SOL,
-  GPT_53_CODEX,
   TEXT_EMBEDDING_3_LARGE,
   TEXT_EMBEDDING_3_SMALL,
 ]);

package/src/models/inventory-core.js

@@ -24,6 +24,75 @@ export const WORKERS_AI_CURATED_MODEL_IDS = Object.freeze([
 ]);
 
 const CURATED = new Set(WORKERS_AI_CURATED_MODEL_IDS);
+export const PROVIDER_MODEL_SNAPSHOT_SCHEMA = 'agentsam.provider-model-snapshot.v1';
+
+function modelSnapshotHash(modelIds) {
+  const source = modelIds.join('\n');
+  let hash = 2166136261;
+  for (let index = 0; index < source.length; index += 1) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, '0')}`;
+}
+
+/**
+ * Compact credential-scoped availability evidence for an existing
+ * `agentsam_plugins` AI installation. The global catalog remains curated
+ * reference data; discovery never creates one model row per user.
+ */
+export function createProviderModelSnapshot(provider, models = [], options = {}) {
+  const providerId = String(provider || '').trim().toLowerCase();
+  if (!providerId) throw new TypeError('provider_required');
+  const modelIds = [...new Set(models.map((row) => String(
+    typeof row === 'string' ? row : row?.provider_model_id || row?.model_id || '',
+  ).trim()).filter(Boolean))].sort();
+  const fetchedAtUnix = Number.isFinite(Number(options.fetchedAtUnix))
+    ? Math.max(0, Math.floor(Number(options.fetchedAtUnix)))
+    : Math.floor(Date.now() / 1000);
+  return Object.freeze({
+    schema: PROVIDER_MODEL_SNAPSHOT_SCHEMA,
+    provider: providerId,
+    model_ids: Object.freeze(modelIds),
+    model_count: modelIds.length,
+    models_hash: modelSnapshotHash(modelIds),
+    fetched_at_unix: fetchedAtUnix,
+    authority: 'credential_scoped_provider_discovery',
+  });
+}
+
+/**
+ * Produce fields for the existing `agentsam_plugins` row. Failed probes keep
+ * the last good snapshot while updating health evidence; no secret or model
+ * catalog rows are written.
+ */
+export function createAiPluginProbePatch(previousMetadata = {}, discovery = {}, options = {}) {
+  const now = Number.isFinite(Number(options.fetchedAtUnix))
+    ? Math.max(0, Math.floor(Number(options.fetchedAtUnix)))
+    : Math.floor(Date.now() / 1000);
+  const metadata = previousMetadata && typeof previousMetadata === 'object' && !Array.isArray(previousMetadata)
+    ? { ...previousMetadata }
+    : {};
+  if (discovery.ok === true) {
+    metadata.model_snapshot = createProviderModelSnapshot(
+      options.provider || discovery.provider,
+      discovery.models || [],
+      { fetchedAtUnix: now },
+    );
+  }
+  const error = String(discovery.error || '').trim();
+  const authFailure = /\b(?:401|403)\b|unauthoriz|forbidden|invalid[_ -]?(?:api[_ -]?)?key|credential.*reject/i.test(error);
+  return Object.freeze({
+    metadata,
+    health_status: discovery.ok === true ? 'healthy' : authFailure ? 'auth_error' : 'unreachable',
+    last_health_at: now,
+    ...(discovery.ok === true ? { last_healthy_at: now, consecutive_failures: 0, last_error_code: null, last_error_message: null } : {
+      consecutive_failures_delta: 1,
+      last_error_code: authFailure ? 'provider_credential_rejected' : 'provider_discovery_failed',
+      last_error_message: authFailure ? 'Provider credential rejected' : 'Provider model discovery failed',
+    }),
+  });
+}
 
 const SERVICE_TO_PROVIDER = Object.freeze({
   openai: 'openai',

package/src/plugins/index.js

@@ -5,7 +5,14 @@ export {
   INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST,
 } from './cloudflare.js';
 export { COMPLETEFUL_PLUGIN_MANIFEST } from './completeful.js';
-export { installPlugin, listPlugins, listPluginTools, recordPluginHealthCheck, recordToolCall } from './registry.js';
+export {
+  installPlugin,
+  listPlugins,
+  listPluginTools,
+  recordPluginHealthCheck,
+  recordAiPluginModelDiscovery,
+  recordToolCall,
+} from './registry.js';
 export { createPluginRuntime, createPluginCapabilityAdapter, executeAgentSamTool } from './runtime.js';
 export { resolveProjectPluginScope, resolveProjectPluginResources, resolveProjectRuntimeResources, resolveProjectVectorizeScope } from './resource-scope.js';
 export { resolveVectorizeConfig, executeVectorizeTool } from './vectorize.js';

package/src/plugins/registry.js

@@ -1,4 +1,5 @@
 import { normalizePluginManifest } from './contracts.js';
+import { createAiPluginProbePatch } from '../models/inventory-core.js';
 
 function clean(value) { return value == null ? '' : String(value).trim(); }
 function json(value, fallback) { try { return JSON.parse(String(value ?? '')); } catch { return fallback; } }
@@ -188,6 +189,61 @@ export async function recordPluginHealthCheck(db, value = {}) {
   return { id: checkId, status: value.status };
 }
 
+/**
+ * Persist credential-verified AI model availability in the existing plugin
+ * installation metadata. A failed probe records health evidence but preserves
+ * the last successful model snapshot.
+ */
+export async function recordAiPluginModelDiscovery(db, value = {}) {
+  if (!db?.prepare) throw new TypeError('D1-compatible database binding required');
+  const pluginId = clean(value.pluginId);
+  const accountId = clean(value.accountId);
+  if (!pluginId) throw new Error('plugin_id_required');
+  if (!accountId) throw new Error('plugin_account_id_required');
+  const plugin = await db.prepare(`
+    SELECT id, plugin_key, provider_key, environment, plugin_kind, metadata_json
+    FROM agentsam_plugins WHERE id = ? AND account_id = ? LIMIT 1
+  `).bind(pluginId, accountId).first();
+  if (!plugin) throw new Error(`plugin_not_found:${pluginId}`);
+  if (clean(plugin.plugin_kind) !== 'ai') throw new Error(`plugin_not_ai:${pluginId}`);
+
+  const probe = createAiPluginProbePatch(json(plugin.metadata_json, {}), value.discovery || {}, {
+    provider: value.provider || plugin.provider_key,
+    fetchedAtUnix: value.completedAt,
+  });
+  await runMutation(db, `
+    UPDATE agentsam_plugins SET metadata_json = ?, updated_at = unixepoch()
+    WHERE id = ? AND account_id = ?
+  `, [JSON.stringify(probe.metadata), pluginId, accountId]);
+
+  const snapshot = probe.metadata.model_snapshot || null;
+  const health = await recordPluginHealthCheck(db, {
+    pluginId,
+    pluginKey: plugin.plugin_key,
+    accountId,
+    environment: plugin.environment,
+    checkKind: 'model_inventory',
+    checkSource: value.checkSource || 'provider_discovery',
+    status: probe.health_status,
+    startedAt: value.startedAt,
+    completedAt: probe.last_health_at,
+    latencyMs: value.latencyMs,
+    httpStatus: value.httpStatus,
+    providerRequestId: value.providerRequestId,
+    errorCode: probe.last_error_code,
+    errorMessage: probe.last_error_message,
+    details: snapshot ? {
+      schema: snapshot.schema,
+      provider: snapshot.provider,
+      model_count: snapshot.model_count,
+      models_hash: snapshot.models_hash,
+      fetched_at_unix: snapshot.fetched_at_unix,
+      ...(value.discovery?.ok === true ? {} : { snapshot_preserved: true }),
+    } : { provider: clean(value.provider || plugin.provider_key), snapshot_preserved: true },
+  });
+  return Object.freeze({ ...health, plugin_id: pluginId, health_status: probe.health_status, model_snapshot: snapshot });
+}
+
 export async function recordToolCall(db, value = {}) {
   const callId = clean(value.id) || id('atcl');
   await runMutation(db, `

package/src/rpc/generated/errors_pb.js

@@ -103,7 +103,8 @@ proto.agentsam.knowledge.v1.ErrorDetail.toObject = function(includeInstance, msg
     detailsJson: jspb.Message.getFieldWithDefault(msg, 25, ""),
     occurrenceCount: jspb.Message.getFieldWithDefault(msg, 26, 0),
     requestId: jspb.Message.getFieldWithDefault(msg, 27, ""),
-    schemaVersion: jspb.Message.getFieldWithDefault(msg, 28, 0)
+    schemaVersion: jspb.Message.getFieldWithDefault(msg, 28, 0),
+    nativeStage: jspb.Message.getFieldWithDefault(msg, 29, "")
   };
 
   if (includeInstance) {
@@ -252,6 +253,10 @@ proto.agentsam.knowledge.v1.ErrorDetail.deserializeBinaryFromReader = function(m
       var value = /** @type {number} */ (reader.readUint32());
       msg.setSchemaVersion(value);
       break;
+    case 29:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setNativeStage(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -477,6 +482,13 @@ proto.agentsam.knowledge.v1.ErrorDetail.serializeBinaryToWriter = function(messa
       f
     );
   }
+  f = /** @type {string} */ (jspb.Message.getField(message, 29));
+  if (f != null) {
+    writer.writeString(
+      29,
+      f
+    );
+  }
 };
 
 
@@ -1416,6 +1428,42 @@ proto.agentsam.knowledge.v1.ErrorDetail.prototype.hasSchemaVersion = function()
 };
 
 
+/**
+ * optional string native_stage = 29;
+ * @return {string}
+ */
+proto.agentsam.knowledge.v1.ErrorDetail.prototype.getNativeStage = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 29, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.agentsam.knowledge.v1.ErrorDetail} returns this
+ */
+proto.agentsam.knowledge.v1.ErrorDetail.prototype.setNativeStage = function(value) {
+  return jspb.Message.setField(this, 29, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.agentsam.knowledge.v1.ErrorDetail} returns this
+ */
+proto.agentsam.knowledge.v1.ErrorDetail.prototype.clearNativeStage = function() {
+  return jspb.Message.setField(this, 29, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.agentsam.knowledge.v1.ErrorDetail.prototype.hasNativeStage = function() {
+  return jspb.Message.getField(this, 29) != null;
+};
+
+
 /**
  * @enum {number}
  */

package/src/tools/runtime.js

@@ -1,4 +1,4 @@
-import { ERROR_REASON_POLICY, normalizeError } from '../errors/index.js';
+import { ERROR_REASON_POLICY, canonicalizeErrorReason, normalizeError } from '../errors/index.js';
 import { receiptPayload, redactToolValue } from './redact.js';
 
 function defaultId(prefix) {
@@ -6,6 +6,11 @@ function defaultId(prefix) {
 }
 
 function reasonForError(error) {
+  const nativeReason = canonicalizeErrorReason(error);
+  if (/^(hook|mcp|lsp|tool|provider)_/.test(nativeReason || '')) return nativeReason;
+  const message = String(error?.message || error || '').toLowerCase();
+  if (message.includes('provider adapter not registered') || message.includes('no registered execution target')) return 'tool_handler_unavailable';
+  if (/timeout|timed out|deadline/.test(message)) return 'tool_timeout';
   const status = Number(error?.status || error?.http_status || 0);
   if (status === 401) return 'provider_credential_invalid';
   if (status === 403) return 'provider_scope_insufficient';
@@ -16,12 +21,12 @@ function reasonForError(error) {
   if (status === 400 || status === 422) return 'provider_request_invalid';
   if (error?.code === 'completeful_idempotency_required') return 'input_invalid';
   if (error instanceof TypeError) return 'input_invalid';
-  return 'execution_failed';
+  return nativeReason || 'tool_execution_failed';
 }
 
-function normalizeToolError(error, definition) {
+function normalizeToolError(error, definition, sideEffectState = 'unknown') {
   const reason = reasonForError(error);
-  const policy = ERROR_REASON_POLICY[reason] || ERROR_REASON_POLICY.execution_failed;
+  const policy = ERROR_REASON_POLICY[reason] || ERROR_REASON_POLICY.tool_execution_failed;
   return normalizeError(error, {
     code: policy.code,
     reason,
@@ -29,6 +34,9 @@ function normalizeToolError(error, definition) {
       ? { kind: 'provider', name: definition.provider, service: definition.provider }
       : { kind: 'runtime', name: 'agentsam-tool-runtime' },
     domain: 'tool',
+    stage: 'execute',
+    feature: 'tool.execute',
+    side_effect_state: sideEffectState,
     tool: definition.toolKey,
     provider: definition.provider || null,
     provider_code: error?.code || null,
@@ -132,7 +140,7 @@ export function createToolExecutor({
     try {
       invoke = await resolveExecutionTarget(registry, definition);
     } catch (error) {
-      const normalized = normalizeToolError(error, definition);
+      const normalized = normalizeToolError(error, definition, 'not_started');
       const completedAt = now();
       const receipt = {
         invocationId: invocation.id,