@inneranimalmedia/agentsam-sdk 2.6.1 → 2.6.3

package/src/providers/openai-responses.js

@@ -1,3 +1,4 @@
+import { compileToolSchema } from './tool-schema.js';
 import { calculateModelCost, getModelRecord } from '../models/index.js';
 import { createAgentEvent, createUsageSnapshot } from '../telemetry/index.js';
 import { createOpenAIHttpError, diagnosticFromError } from '../errors/index.js';
@@ -87,20 +88,42 @@ function usageParts(response = {}) {
   };
 }
 
-function normalizeTools(tools = []) {
+const RESPONSES_BUILTIN_TOOL_CAPABILITIES = Object.freeze({
+  web_search: 'web_search',
+  file_search: 'file_search',
+  image_generation: 'image_generation',
+  code_interpreter: 'code_interpreter',
+  shell: 'hosted_shell',
+  mcp: 'mcp',
+  tool_search: 'tool_search',
+});
+
+function normalizeTools(tools = [], provider = 'openai', capabilities = {}) {
   if (!Array.isArray(tools)) throw new TypeError('tools must be an array');
   return tools.map((tool) => {
-    if (tool?.type !== 'function' || !clean(tool.name)) {
-      throw new TypeError('OpenAI-compatible adapter tools must be Responses function tool descriptors');
+    if (tool?.type === 'function') {
+      if (!clean(tool.name)) throw new TypeError('Responses function tools require a name');
+      return {
+        type: 'function',
+        name: clean(tool.name),
+        description: clean(tool.description) || undefined,
+        parameters: compileToolSchema({ provider, canonicalSchema: tool.parameters, strict: tool.strict !== false, name: tool.name }).providerSchema,
+        strict: tool.strict !== false,
+        ...(tool.async === true ? { async: true } : {}),
+        ...(tool.defer_loading === true ? { defer_loading: true } : {}),
+        ...(Array.isArray(tool.allowed_callers) ? { allowed_callers: [...tool.allowed_callers] } : {}),
+      };
     }
-    return {
-      type: 'function',
-      name: clean(tool.name),
-      description: clean(tool.description) || undefined,
-      parameters: tool.parameters || { type: 'object', properties: {} },
-      strict: tool.strict !== false,
-      ...(tool.async === true ? { async: true } : {}),
-    };
+
+    const type = clean(tool?.type);
+    const capability = RESPONSES_BUILTIN_TOOL_CAPABILITIES[type];
+    if (provider !== 'openai' || !capability) {
+      throw new TypeError('OpenAI-compatible adapter tool type is not supported by this runtime: ' + (type || 'unknown'));
+    }
+    if (capabilities?.[capability] !== true) {
+      throw new RangeError('selected model does not declare Responses tool support: ' + type);
+    }
+    return structuredClone(tool);
   });
 }
 
@@ -212,9 +235,11 @@ export function createOpenAIResponsesAdapter(options = {}) {
     const record = assertRuntimeConfig(model, reasoningEffort, serviceTier, modelRecord, providerId);
     const emit = params.emit || defaultEmit;
     const meta = { runId: params.runId, sequence: params.sequence };
-    const tools = normalizeTools(params.tools || []);
+    const tools = normalizeTools(params.tools || [], providerId, record.capabilities || {});
     const previousResponseId = clean(params.previousResponseId || params.providerState?.previous_response_id);
-    const requestInput = providerId === 'grok'
+    const requestInput = !previousResponseId && Array.isArray(params.providerState?.compacted_input)
+      ? [...structuredClone(params.providerState.compacted_input), ...historyItems(params.input)]
+      : providerId === 'grok'
       && !previousResponseId
       && Array.isArray(params.providerState?.compaction_input)
       && params.providerState.compaction_input.length
@@ -228,6 +253,8 @@ export function createOpenAIResponsesAdapter(options = {}) {
       ...(providerId === 'openai' || serviceTier !== 'default' ? { service_tier: serviceTier } : {}),
       store: params.store !== false,
       truncation: 'disabled',
+      ...(providerId === 'openai' && record.capabilities?.compaction === true && params.autoCompact !== false && Number.isInteger(record.context_policy?.compact_at_tokens)
+        ? { context_management: [{ type: 'compaction', compact_threshold: record.context_policy.compact_at_tokens }] } : {}),
       parallel_tool_calls: params.parallelToolCalls !== false,
       ...(clean(params.instructions) ? { instructions: String(params.instructions) } : {}),
       ...(tools.length ? { tools } : {}),
@@ -347,18 +374,18 @@ export function createOpenAIResponsesAdapter(options = {}) {
     const xaiHistory = Array.isArray(params.providerState?.compaction_input)
       ? structuredClone(params.providerState.compaction_input)
       : [];
-    if (providerId === 'grok' && !xaiHistory.length) {
+    if (providerId === 'grok' && !xaiHistory.length && !params.providerState?.compacted_input?.length && !Array.isArray(params.input)) {
       throw new Error('xai_compaction_history_unavailable');
     }
     const body = providerId === 'grok'
       ? {
           model,
-          input: xaiHistory,
+          input: xaiHistory.length ? xaiHistory : params.providerState?.compacted_input || params.input,
         }
       : {
           model,
           ...(previousResponseId ? { previous_response_id: previousResponseId } : {}),
-          ...(params.input != null ? { input: params.input } : {}),
+          ...(params.input != null ? { input: params.input } : Array.isArray(params.providerState?.compacted_input) ? { input: params.providerState.compacted_input } : {}),
           ...(clean(params.instructions) ? { instructions: String(params.instructions) } : {}),
           ...(clean(params.promptCacheKey) ? { prompt_cache_key: clean(params.promptCacheKey) } : {}),
           ...(params.promptCacheOptions ? { prompt_cache_options: params.promptCacheOptions } : {}),
@@ -384,6 +411,7 @@ export function createOpenAIResponsesAdapter(options = {}) {
       throw error;
     }
 
+    if (!Array.isArray(response.output) || !response.output.length) throw new Error('provider_compaction_output_missing');
     const compactUsage = usageParts(response);
     const compactCost = modelRecord.pricing
       ? calculateModelCost(modelRecord, { ...compactUsage, estimate_kind: 'provider' }, { serviceTier: 'default' })
@@ -412,6 +440,7 @@ export function createOpenAIResponsesAdapter(options = {}) {
         ? Object.freeze({ previous_response_id: null, compaction_input: structuredClone(response.output || []) })
         : Object.freeze({ previous_response_id: null }),
       usage: response.usage || null,
+      usage_delta: compactUsage,
       cost: compactCost,
       raw: response,
     });

package/src/providers/tool-schema.js

@@ -0,0 +1,85 @@
+import { createHash } from 'node:crypto';
+
+// Deliberately bounded dialect. Unsupported validation keywords fail locally;
+// never silently weaken a schema or mutate the protocol artifact.
+const annotations = new Set(['$schema', '$id', '$comment', 'title', 'default', 'examples']);
+const keywords = new Set(['type', 'description', 'properties', 'required', 'additionalProperties', 'items', 'anyOf', 'enum', 'const', 'minimum', 'maximum', 'minLength', 'maxLength', 'pattern', 'format', 'minItems', 'maxItems']);
+const types = new Set(['object', 'array', 'string', 'number', 'integer', 'boolean', 'null']);
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+export function compileToolSchema({ provider, canonicalSchema, strict = true, name = 'tool' }) {
+  if (!['openai', 'grok', 'gemini'].includes(provider)) throw new Error(`tool_schema_provider_unsupported:${provider}`);
+  const strictMode = provider !== 'gemini' && strict;
+  const transformations = [];
+  const fail = (path, reason) => { throw new TypeError(`tool_schema_invalid:${provider}:${name}:${path}:${reason}`); };
+  function visit(schema, path, depth = 0) {
+    if (depth > 10) fail(path, 'schema_depth_exceeded');
+    if (!object(schema)) fail(path, 'expected_schema_object');
+    const out = {};
+    for (const [key, value] of Object.entries(schema)) {
+      if (annotations.has(key)) { transformations.push(`${path}:omit:${key}`); continue; }
+      if (!keywords.has(key)) fail(path, `unsupported_keyword:${key}`);
+      Object.defineProperty(out, key, { value: structuredClone(value), enumerable: true, writable: true, configurable: true });
+    }
+    if (out.const !== undefined) { out.enum = [out.const]; delete out.const; }
+    if (out.enum !== undefined && (!Array.isArray(out.enum) || !out.enum.length || out.enum.some(v => v !== null && !['string', 'number', 'boolean'].includes(typeof v)))) fail(path, 'invalid_enum');
+    if (!out.type && out.enum) {
+      const inferred = [...new Set(out.enum.map(v => v === null ? 'null' : typeof v))];
+      out.type = inferred.length === 1 ? inferred[0] : inferred;
+    }
+    if (!out.type && out.properties) out.type = 'object';
+    const declared = Array.isArray(out.type) ? out.type : out.type ? [out.type] : [];
+    if (declared.some(t => !types.has(t)) || new Set(declared).size !== declared.length) fail(path, 'invalid_type');
+    if (!declared.length && !out.anyOf) fail(path, 'unbounded_schema');
+    if (out.anyOf) {
+      if (!Array.isArray(out.anyOf) || !out.anyOf.length) fail(path, 'invalid_anyOf');
+      out.anyOf = out.anyOf.map((s, i) => visit(s, `${path}.anyOf[${i}]`, depth + 1));
+    }
+    for (const key of ['minimum', 'maximum', 'minLength', 'maxLength', 'minItems', 'maxItems']) {
+      if (out[key] !== undefined && (!Number.isFinite(out[key]) || (!['minimum', 'maximum'].includes(key) && (!Number.isInteger(out[key]) || out[key] < 0)))) fail(path, `invalid_${key}`);
+    }
+    for (const [min, max] of [['minimum', 'maximum'], ['minLength', 'maxLength'], ['minItems', 'maxItems']]) {
+      if (out[min] !== undefined && out[max] !== undefined && out[min] > out[max]) fail(path, `invalid_bounds:${min}`);
+    }
+    for (const key of ['description', 'pattern', 'format']) if (out[key] !== undefined && typeof out[key] !== 'string') fail(path, `invalid_${key}`);
+    if (out.pattern) { try { new RegExp(out.pattern); } catch { fail(path, 'invalid_pattern'); } }
+    if (out.format && !['date-time', 'time', 'date', 'duration', 'email', 'hostname', 'ipv4', 'ipv6', 'uuid'].includes(out.format)) fail(path, 'unsupported_format');
+    if (declared.includes('object')) {
+      const props = out.properties ?? {};
+      if (!object(props)) fail(path, 'invalid_properties');
+      const required = out.required ?? [];
+      if (!Array.isArray(required) || new Set(required).size !== required.length || required.some(k => typeof k !== 'string' || !Object.hasOwn(props, k))) fail(path, 'invalid_required');
+      if (out.additionalProperties !== undefined && typeof out.additionalProperties !== 'boolean') fail(path, 'dynamic_properties_unsupported');
+      if (strictMode && out.additionalProperties === true) fail(path, 'open_object_not_strict');
+      out.properties = Object.fromEntries(Object.entries(props).map(([key, schema]) => {
+        let child = visit(schema, `${path}.properties.${key}`, depth + 1);
+        if (strictMode && !required.includes(key)) {
+          child = { anyOf: [child, { type: 'null' }] };
+          transformations.push(`${path}.${key}:optional_to_nullable`);
+        }
+        return [key, child];
+      }));
+      out.required = strictMode ? Object.keys(props) : required;
+      if (strictMode) out.additionalProperties = false;
+    } else if (out.properties || out.required || out.additionalProperties !== undefined) fail(path, 'object_keywords_without_object');
+    if (declared.includes('array')) {
+      if (!out.items) fail(path, 'array_items_required');
+      out.items = visit(out.items, `${path}.items`, depth + 1);
+    } else if (out.items) fail(path, 'items_without_array');
+    return out;
+  }
+  const providerSchema = visit(canonicalSchema ?? { type: 'object', properties: {}, required: [], additionalProperties: false }, '$');
+  if (providerSchema.type !== 'object' || providerSchema.anyOf) fail('$', 'root_must_be_object');
+  return { providerSchema, transformations, warnings: [], unsupportedKeywords: [], hash: createHash('sha256').update(JSON.stringify(providerSchema)).digest('hex') };
+}
+
+// Null added by a strict projection means omission in the canonical contract.
+export function restoreOptionalArguments(value, schema) {
+  if (Array.isArray(value)) return value.map(v => restoreOptionalArguments(v, schema?.items));
+  if (!object(value)) return value;
+  return Object.fromEntries(Object.entries(value).filter(([key, v]) => {
+    const child = schema?.properties?.[key];
+    const nullable = child?.type === 'null' || child?.type?.includes?.('null') || child?.anyOf?.some(s => s.type === 'null');
+    return !(v === null && child && !schema?.required?.includes(key) && !nullable);
+  }).map(([key, v]) => [key, restoreOptionalArguments(v, schema?.properties?.[key])]));
+}

package/src/repository/index.js

@@ -14,3 +14,32 @@ export {
   createRepositoryContract,
   createRepositoryDependency,
 } from '../../packages/agentsam-repository/src/contracts.js';
+export {
+  scanGitCommits,
+  generateGitCommitIngestSql,
+  syncGitCommitsToD1,
+} from '../../packages/agentsam-repository/src/work-tracking.js';
+export {
+  createAgentRunId,
+  createTicketId,
+  generateTicketCreateSql,
+  generateTicketActivationSql,
+  generateTicketCloseSql,
+} from '../../packages/agentsam-repository/src/tickets.js';
+export {
+  generateWorkspaceStateUpsertSql,
+  readWorkspaceStateFromD1,
+  syncWorkspaceStateToD1,
+} from '../../packages/agentsam-repository/src/workspace-state.js';
+export {
+  readGoapState,
+  listGoapTickets,
+  createGoapGoal,
+  switchGoapGoal,
+  closeGoapGoal,
+  renderGoapStatus,
+  renderGoapList,
+  renderGoapGoal,
+  renderGoapWhy,
+  renderGoapPlan,
+} from '../../packages/agentsam-repository/src/goap.js';