@animalabs/connectome-host 0.3.9 → 0.4.0

package/src/index.ts

@@ -16,12 +16,17 @@
  */
 
 import {
+  AnthropicXmlFormatter,
+  BedrockAdapter,
   Membrane,
   NativeFormatter,
   OpenAIResponsesAPIAdapter,
   OpenAIResponsesFormatter,
+  OpenRouterAdapter,
 } from '@animalabs/membrane';
 import { LoggingAnthropicAdapter } from './logging-adapter.js';
+import { LoggingBedrockAdapter } from './logging-bedrock-adapter.js';
+import { CodexSubscriptionAdapter } from './codex-subscription-adapter.js';
 import { CallLedger } from './call-ledger.js';
 import { SettingsModule } from './modules/settings-module.js';
 import { AgentFramework, WorkspaceModule, resolveTimeZone, type Module, type MountConfig } from '@animalabs/agent-framework';
@@ -41,6 +46,7 @@ import { ChannelModeModule } from './modules/channel-mode-module.js';
 import { WebUiModule } from './modules/web-ui-module.js';
 import { ObserversModule } from './modules/observers-module.js';
 import { McplAdminModule } from './modules/mcpl-admin-module.js';
+import { TtsRelayModule } from './modules/tts-relay-module.js';
 import { loadMcplServers, applyAgentOverlay, DEFAULT_CONFIG_PATH, DEFAULT_AGENT_OVERLAY_PATH } from './mcpl-config.js';
 import { SessionManager } from './session-manager.js';
 import { resolveAgentName } from './agent-name.js';
@@ -57,6 +63,7 @@ import {
 import { createBranchState, resetBranchState, handleExport, type BranchState } from './commands.js';
 import { buildFrameworkAgentConfig } from './framework-agent-config.js';
 import { buildFrameworkStrategy } from './framework-strategy.js';
+import { loadExtensions } from './extensions.js';
 
 export type { AppContext };
 
@@ -69,6 +76,8 @@ const config = {
   // precedence over the API key so requests never carry both auth schemes.
   authToken: process.env.ANTHROPIC_AUTH_TOKEN,
   openaiApiKey: process.env.OPENAI_API_KEY,
+  openrouterApiKey: process.env.OPENROUTER_API_KEY,
+  codexBinary: process.env.CODEX_BINARY,
   model: process.env.MODEL,
   dataDir: process.env.DATA_DIR || './data',
 };
@@ -91,6 +100,7 @@ interface AppContext {
   agentName: string;
   branchState: BranchState;
   userMessageCount: number;
+  codexAdapter?: CodexSubscriptionAdapter;
 
   /** Stop current framework, switch to a different session, start new framework. */
   switchSession(id: string): Promise<void>;
@@ -143,10 +153,16 @@ async function createFramework(
   settingsModule: SettingsModule,
   callLedger: CallLedger | null,
 ): Promise<AgentFramework> {
-  const model = config.model || recipe.agent.model || 'claude-opus-4-6';
+  const model = config.model || recipe.agent.model ||
+    (recipe.agent.provider === 'openai-codex' ? 'gpt-5.4' : 'claude-opus-4-6');
   const modules = recipe.modules ?? {};
   const timeZone = resolveTimeZone(recipe.agent.timezone);
 
+  // Load recipe extensions first — custom strategies must be registered
+  // before buildFrameworkStrategy runs, and custom modules join the module
+  // list below. The loader is a dumb local import; see src/extensions.ts.
+  const extensionRegistry = await loadExtensions(recipe);
+
   // -- Build module list --
   // SettingsModule is constructed in main() (before the adapter, so the
   // adapter can read its state for cross-cutting concerns like reasoning).
@@ -342,6 +358,24 @@ async function createFramework(
     moduleInstances.push(new ObserversModule({ path: observersPath }));
   }
 
+  // TTS relay tap — opt-in per recipe. Pure trace-bus consumer: mirrors the
+  // agent's streaming generation to a melodeus-tts-relay /bot endpoint and
+  // trims posted messages on voice interruptions. See modules.ttsRelay in
+  // recipe.ts for the config contract (url/token validated at recipe load).
+  if (modules.ttsRelay) {
+    moduleInstances.push(new TtsRelayModule(modules.ttsRelay));
+  }
+
+  // Extension-registered modules. Instantiated last so built-in modules keep
+  // their historical positions; each factory gets the minimal runtime context
+  // plus its declaring extension's config blob.
+  const extensionModules: Module[] = [];
+  for (const entry of extensionRegistry.modules) {
+    const instance = entry.factory({ timeZone, storePath, model, config: entry.config });
+    extensionModules.push(instance);
+    moduleInstances.push(instance);
+  }
+
   // -- Build MCP server list --
   //
   // Recipes are opt-in: a file entry from mcpl-servers.json is loaded only
@@ -401,14 +435,14 @@ async function createFramework(
   // No server augmentation needed — gate is wired via FrameworkConfig.gate
 
   // -- Build strategy --
-  const strategy = buildFrameworkStrategy(recipe, model, timeZone);
+  const strategy = buildFrameworkStrategy(recipe, model, timeZone, extensionRegistry);
   const agentConfig = buildFrameworkAgentConfig(recipe, agentName, model, strategy);
 
   // -- Create framework --
   const framework = await AgentFramework.create({
     storePath,
     membrane,
-    agents: [agentConfig],
+agents: [agentConfig],
     modules: moduleInstances,
     mcplServers: finalServers,
     gate: gateOptions,
@@ -467,6 +501,13 @@ async function createFramework(
     channelModeModule.setFramework(framework);
   }
 
+  // Extension modules get the same duck-typed post-creation hook the
+  // built-ins use: if the instance exposes setFramework, call it.
+  for (const instance of extensionModules) {
+    const hooked = instance as unknown as { setFramework?: (f: AgentFramework) => void };
+    hooked.setFramework?.(framework);
+  }
+
   if (mcplAdminModule) {
     mcplAdminModule.setFramework(framework);
   }
@@ -733,10 +774,18 @@ async function main() {
   const recipe = await resolveRecipe();
   const provider = recipe.agent.provider ?? 'anthropic';
 
+  if (provider === 'openrouter' && !config.openrouterApiKey) {
+    console.error('Missing OPENROUTER_API_KEY for recipe provider "openrouter".');
+    process.exit(1);
+  }
   if (provider === 'openai-responses' && !config.openaiApiKey) {
     console.error('Missing OPENAI_API_KEY for recipe provider "openai-responses".');
     process.exit(1);
   }
+  if (provider === 'bedrock' && !(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY)) {
+    console.error('Missing AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY for recipe provider "bedrock".');
+    process.exit(1);
+  }
   if (provider === 'anthropic' && !config.apiKey && !config.authToken) {
     console.error('Missing ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN). Set one in .env or environment.');
     process.exit(1);
@@ -761,22 +810,54 @@ async function main() {
         defaultTtl: recipe.agent.cacheTtl ?? '5m',
       })
     : null;
-  // OAuth (subscription) auth wins over API-key auth when both are present.
-  // Subscription tokens (sk-ant-oat…) additionally require the oauth beta
-  // header on every request.
+  // The Codex subscription adapter owns ChatGPT login/refresh independently
+  // of the API-key transports below.
+  const codexAdapter = provider === 'openai-codex'
+    ? new CodexSubscriptionAdapter({
+        codexBinary: config.codexBinary,
+        fastMode: recipe.agent.codex?.fastMode ?? false,
+      })
+    : undefined;
+  const openrouterAdapter = provider === 'openrouter'
+    ? new OpenRouterAdapter({
+        apiKey: config.openrouterApiKey!,
+        xTitle: recipe.agent.name ?? recipe.name,
+      })
+    : undefined;
+  // Bedrock: legacy Claude models (3.5 Sonnet 0620/1022, Opus 3) that have
+  // left the Anthropic API but survive on AWS. The adapter reads AWS_* env
+  // vars (AWS_REGION defaults us-west-2) and maps standard Claude model IDs
+  // to Bedrock IDs (explicit map + `anthropic.<id>-v1:0` fallback). Uses the
+  // Anthropic-native message shape, so NativeFormatter applies unchanged.
+  // No CallLedger: prompt caching is rejected outright by legacy Bedrock
+  // models (tested 2026-07-21). Wrapped for llm-calls.jsonl visibility.
+  const bedrockAdapter = provider === 'bedrock'
+    ? new LoggingBedrockAdapter({}, llmLogPath)
+    : undefined;
   const adapter = provider === 'openai-responses'
     ? new OpenAIResponsesAPIAdapter({
         apiKey: config.openaiApiKey!,
         baseURL: process.env.OPENAI_BASE_URL || undefined,
       })
-    : new LoggingAnthropicAdapter(
+    : bedrockAdapter ?? openrouterAdapter ?? codexAdapter ?? new LoggingAnthropicAdapter(
         {
+          // Anthropic OAuth wins over API-key auth when both are present.
+          // Subscription tokens additionally require this beta header.
+          // Recipe-declared betas (agent.anthropicBetas, e.g. context-1m)
+          // are merged into the same anthropic-beta header either way.
           ...(config.authToken
             ? {
                 authToken: config.authToken,
-                defaultHeaders: { 'anthropic-beta': 'oauth-2025-04-20' },
+                defaultHeaders: {
+                  'anthropic-beta': ['oauth-2025-04-20', ...(recipe.agent.anthropicBetas ?? [])].join(','),
+                },
               }
-            : { apiKey: config.apiKey! }),
+            : {
+                apiKey: config.apiKey!,
+                ...(recipe.agent.anthropicBetas?.length
+                  ? { defaultHeaders: { 'anthropic-beta': recipe.agent.anthropicBetas.join(',') } }
+                  : {}),
+              }),
           baseURL: process.env.ANTHROPIC_BASE_URL || undefined,
         },
         llmLogPath,
@@ -815,9 +896,15 @@ async function main() {
   const agentName = resolved.name;
 
   const membrane = new Membrane(adapter, {
-    formatter: provider === 'openai-responses'
+    formatter: provider === 'openai-responses' || provider === 'openai-codex'
       ? new OpenAIResponsesFormatter()
-      : new NativeFormatter(),
+      : recipe.agent.formatter === 'anthropic-xml'
+        ? new AnthropicXmlFormatter()
+        : new NativeFormatter(),
+    // Bedrock legacy Claude models 400 on any cache_control block
+    // ("your request did not allow prompt caching") — suppress the
+    // historical promptCaching=true default on that transport.
+    ...(provider === 'bedrock' ? { defaultPromptCaching: false } : {}),
     // Anchor the assistant role for internal callers that don't set
     // request.assistantParticipant themselves (autobio compression,
     // executeMerge). Mismatch here flips stored assistant turns to
@@ -837,6 +924,7 @@ async function main() {
     agentName,
     branchState: createBranchState(),
     userMessageCount: 0,
+    codexAdapter,
 
     async switchSession(id: string) {
       handleExport(this);
@@ -884,14 +972,18 @@ async function main() {
   setupMcplStderrLog(app, storePath);
   getWebUiModule(framework)?.setApp(app);
 
-  if (headless) {
-    const { runHeadless } = await import('./headless.js');
-    await runHeadless(app, process.argv.slice(2));
-  } else if (noTui) {
-    await runPiped(app);
-  } else {
-    const { runTui } = await import('./tui.js');
-    await runTui(app);
+  try {
+    if (headless) {
+      const { runHeadless } = await import('./headless.js');
+      await runHeadless(app, process.argv.slice(2));
+    } else if (noTui) {
+      await runPiped(app);
+    } else {
+      const { runTui } = await import('./tui.js');
+      await runTui(app);
+    }
+  } finally {
+    codexAdapter?.dispose();
   }
 }
 

package/src/logging-bedrock-adapter.ts

@@ -0,0 +1,145 @@
+// BedrockAdapter wrapper that appends each LLM call's request summary, stop
+// reason, and any error to the same `llm-calls.<iso>.jsonl` file the
+// Anthropic path uses. Purpose-built during the Aria bring-up (2026-07-21)
+// when a 0-token assistant turn proved undiagnosable: the bedrock transport
+// had no wire visibility at all.
+//
+// Kept deliberately lighter than LoggingAnthropicAdapter: request summaries
+// always include tool NAMES (were tools attached at all? — the question that
+// motivated this file), message/system sizes, and the stop sequences; the
+// full raw request is retained only on errors. Responses log stop_reason,
+// usage, and content-block shape (type + size per block) on every call.
+//
+// Each line: { type: 'call'|'error', kind: 'complete'|'stream', timestamp,
+//   durationMs, requestSummary, response?, rawRequest?, error? }
+
+import { BedrockAdapter } from '@animalabs/membrane';
+import type {
+  ProviderRequest,
+  ProviderResponse,
+  ProviderRequestOptions,
+  StreamCallbacks,
+} from '@animalabs/membrane';
+import { appendFileSync } from 'node:fs';
+
+type BedrockConfig = ConstructorParameters<typeof BedrockAdapter>[0];
+
+function summarizeRequest(request: ProviderRequest): Record<string, unknown> {
+  const msgs = (request.messages ?? []) as Array<{ role?: string; content?: unknown }>;
+  const last = msgs[msgs.length - 1];
+  const lastPreview = typeof last?.content === 'string'
+    ? last.content.slice(0, 200)
+    : Array.isArray(last?.content)
+      ? (last.content as Array<{ type?: string; text?: string }>)
+          .map((b) => (b.type === 'text' ? (b.text ?? '').slice(0, 120) : `[${b.type}]`))
+          .join(' | ').slice(0, 300)
+      : undefined;
+  return {
+    model: request.model,
+    maxTokens: request.maxTokens,
+    messageCount: msgs.length,
+    systemChars: typeof request.system === 'string'
+      ? request.system.length
+      : Array.isArray(request.system)
+        ? JSON.stringify(request.system).length
+        : 0,
+    toolNames: (request.tools as Array<{ name?: string }> | undefined)?.map((t) => t.name) ?? null,
+    toolCount: (request.tools as unknown[] | undefined)?.length ?? 0,
+    stopSequences: request.stopSequences ?? null,
+    lastMessageRole: last?.role,
+    lastMessagePreview: lastPreview,
+  };
+}
+
+function summarizeResponse(response: ProviderResponse): Record<string, unknown> {
+  const content = (response.content ?? []) as Array<{ type?: string; text?: string; name?: string }>;
+  return {
+    stopReason: response.stopReason ?? (response.raw as { stop_reason?: string } | undefined)?.stop_reason ?? null,
+    usage: response.usage ?? null,
+    blocks: content.map((b) => ({
+      type: b.type,
+      ...(b.type === 'text' ? { chars: (b.text ?? '').length } : {}),
+      ...(b.type === 'tool_use' ? { name: b.name } : {}),
+    })),
+  };
+}
+
+export class LoggingBedrockAdapter extends BedrockAdapter {
+  private readonly logPath: string;
+
+  constructor(config: BedrockConfig, logPath: string) {
+    super(config);
+    this.logPath = logPath;
+  }
+
+  private log(record: Record<string, unknown>): void {
+    try {
+      appendFileSync(this.logPath, JSON.stringify(record) + '\n');
+    } catch {
+      // Logging must never break inference.
+    }
+  }
+
+  override async complete(
+    request: ProviderRequest,
+    options?: ProviderRequestOptions,
+  ): Promise<ProviderResponse> {
+    const started = Date.now();
+    let rawRequest: unknown;
+    const opts: ProviderRequestOptions = {
+      ...options,
+      onRequest: (req) => { rawRequest = req; options?.onRequest?.(req); },
+    };
+    try {
+      const response = await super.complete(request, opts);
+      this.log({
+        type: 'call', kind: 'complete', timestamp: new Date(started).toISOString(),
+        durationMs: Date.now() - started,
+        requestSummary: summarizeRequest(request),
+        response: summarizeResponse(response),
+      });
+      return response;
+    } catch (error) {
+      this.log({
+        type: 'error', kind: 'complete', timestamp: new Date(started).toISOString(),
+        durationMs: Date.now() - started,
+        requestSummary: summarizeRequest(request),
+        rawRequest,
+        error: error instanceof Error ? { message: error.message, name: error.name } : String(error),
+      });
+      throw error;
+    }
+  }
+
+  override async stream(
+    request: ProviderRequest,
+    callbacks: StreamCallbacks,
+    options?: ProviderRequestOptions,
+  ): Promise<ProviderResponse> {
+    const started = Date.now();
+    let rawRequest: unknown;
+    const opts: ProviderRequestOptions = {
+      ...options,
+      onRequest: (req) => { rawRequest = req; options?.onRequest?.(req); },
+    };
+    try {
+      const response = await super.stream(request, callbacks, opts);
+      this.log({
+        type: 'call', kind: 'stream', timestamp: new Date(started).toISOString(),
+        durationMs: Date.now() - started,
+        requestSummary: summarizeRequest(request),
+        response: summarizeResponse(response),
+      });
+      return response;
+    } catch (error) {
+      this.log({
+        type: 'error', kind: 'stream', timestamp: new Date(started).toISOString(),
+        durationMs: Date.now() - started,
+        requestSummary: summarizeRequest(request),
+        rawRequest,
+        error: error instanceof Error ? { message: error.message, name: error.name } : String(error),
+      });
+      throw error;
+    }
+  }
+}

package/src/modules/channel-mode-module.ts

@@ -200,11 +200,13 @@ export class ChannelModeModule implements Module {
     }
 
     // 3. Pin subscription-gc off so a chatty channel doesn't auto-close
-    //    itself back out of debounced mode.
+    //    itself back out of debounced mode. The pin layer sits above
+    //    agent-level overrides, so agent_settings reset/update can't undo it
+    //    and any pre-existing override survives the mode round-trip.
     steps.push(
-      await this.callToolStep('gc-off', `${this.gcModuleName}--set_channel_idle_limit`, {
+      await this.callToolStep('gc-pin', `${this.gcModuleName}--pin_channel_idle_limit`, {
         channelId,
-        limit: 'off',
+        pinned: true,
       }),
     );
 
@@ -225,11 +227,12 @@ export class ChannelModeModule implements Module {
     // 2. Close ambient traffic through the generic host lifecycle.
     steps.push(await this.callToolStep('close', 'channel_close', { channelId, serverId: this.serverId }));
 
-    // 3. Restore the default auto-close limit.
+    // 3. Release the pin; the channel's agent override (if any) or the
+    //    default limit applies again.
     steps.push(
-      await this.callToolStep('gc-default', `${this.gcModuleName}--set_channel_idle_limit`, {
+      await this.callToolStep('gc-unpin', `${this.gcModuleName}--pin_channel_idle_limit`, {
         channelId,
-        limit: 'default',
+        pinned: false,
       }),
     );