talon-agent 3.8.2 → 3.9.1

package/src/backend/codex/index.ts

@@ -1,33 +0,0 @@
-/**
- * Codex backend — barrel re-export.
- *
- * Wraps `@openai/codex-sdk` (which in turn spawns the `codex` CLI from
- * `@openai/codex`) and exposes a Backend-compatible API. The
- * implementation is split across focused modules:
- *
- *   - `constants.ts`   — system-prompt suffix, default model.
- *   - `state.ts`       — per-process state container.
- *   - `init.ts`        — backend init + lazy Codex-instance construction.
- *   - `mcp-config.ts`  — Talon MCP plugins → Codex `--config` TOML.
- *   - `handler.ts`     — main message handler (streaming, end_turn).
- *   - `factory.ts`     — registry registration.
- *
- * MCP integration: Codex configures MCP servers at thread-creation
- * time via TOML overrides. Talon rebuilds the `Codex` instance when
- * the active chat id changes so each chat sees its own MCP server
- * environment (frontend-tools + plugin servers).
- */
-
-export {
-  CODEX_SYSTEM_PROMPT_SUFFIX,
-  CODEX_DEFAULT_MODEL,
-  CODEX_DEFAULT_WORKING_DIRECTORY,
-} from "./constants.js";
-
-export { initCodexAgent, ensureCodex } from "./init.js";
-
-export { handleMessage, getActiveAbort } from "./handler/index.js";
-
-export { runOneShotAgent } from "./one-shot.js";
-
-export { buildCodexMcpServers, type CodexMcpServer } from "./mcp-config.js";

package/src/backend/openai-agents/index.ts

@@ -1,48 +0,0 @@
-/**
- * OpenAI Agents backend — barrel.
- *
- * Importing this module registers the backend with the registry via
- * `factory.ts`'s side-effect import. Most callers should NOT need to
- * reach in here — the bootstrap layer picks the active backend by id.
- */
-
-import "./factory.js";
-
-export {
-  initOpenAIAgentsAgent,
-  getOpenAIApiKey,
-  getOpenAIBaseUrl,
-  triggerDiscoveryRefresh,
-} from "./init.js";
-export {
-  awaitDiscovery,
-  startDiscovery,
-  refreshDiscovery,
-  hasDiscoveredCatalog,
-  fetchEndpointModels,
-  extractCapabilities,
-} from "./discovery.js";
-export { handleMessage, getActiveAbort } from "./handler/index.js";
-export { resetState, getState } from "./state.js";
-export {
-  resolveModel,
-  getModelInfo,
-  getSettingsPresentation,
-  getProviders,
-  getProviderModels,
-  formatModelError,
-  listModels,
-} from "./models.js";
-export {
-  OPENAI_AGENTS_SYSTEM_PROMPT_SUFFIX,
-  OPENAI_AGENTS_DEFAULT_MODEL,
-  OPENAI_AGENTS_MAX_TURNS,
-  OPENAI_AGENTS_AGENT_NAME,
-} from "./constants.js";
-export {
-  getOrCreateBundle,
-  releaseBundle,
-  releaseAllBundles,
-  getActiveBundleIds,
-} from "./mcp-pool.js";
-export type { OpenAIAgentsMcpBundle, BundleInputs } from "./mcp-pool.js";

package/src/cli/plugin-entries.ts

@@ -1,104 +0,0 @@
-/**
- * Pure helpers over the config `plugins` array for the `talon plugin`
- * command group. The CLI edits config.json as JSON — entries here are the
- * on-disk shape (`core/plugin/types.ts` PluginEntry), not loaded plugins.
- * No filesystem or process access — everything is testable data-in/data-out.
- */
-
-/** On-disk plugin entry — path-based module or standalone MCP server. */
-export type PluginEntryJson = {
-  path?: string;
-  config?: Record<string, unknown>;
-  name?: string;
-  command?: string;
-  args?: string[];
-  env?: Record<string, string>;
-  enabled?: boolean;
-};
-
-/**
- * Built-in plugins toggled by their own config sections (`github.enabled`,
- * …) rather than `plugins[]` entries — see core/plugin/builtins.ts.
- */
-export const BUILTIN_PLUGINS = [
-  "github",
-  "mempalace",
-  "mem0",
-  "playwright",
-] as const;
-
-export function isBuiltinPlugin(name: string): boolean {
-  return (BUILTIN_PLUGINS as readonly string[]).includes(name);
-}
-
-/** Split a config path on either separator — Windows configs carry `\`. */
-function pathSegments(path: string): string[] {
-  return path.split(/[\\/]+/).filter(Boolean);
-}
-
-/**
- * Display name for an entry: the MCP name, or for path entries the package
- * name — segments after the last `node_modules` (preserving `@scope/pkg`),
- * else the folder basename.
- */
-export function entryDisplayName(entry: PluginEntryJson): string {
-  if (entry.name) return entry.name;
-  if (!entry.path) return "(invalid entry)";
-  const segments = pathSegments(entry.path);
-  const nm = segments.lastIndexOf("node_modules");
-  if (nm >= 0 && nm < segments.length - 1) {
-    return segments.slice(nm + 1).join("/");
-  }
-  return segments[segments.length - 1] ?? entry.path;
-}
-
-/** Does `token` identify this entry? Display name, basename, or full path. */
-export function entryMatches(entry: PluginEntryJson, token: string): boolean {
-  if (entryDisplayName(entry) === token) return true;
-  if (!entry.path) return false;
-  const segments = pathSegments(entry.path);
-  return entry.path === token || segments[segments.length - 1] === token;
-}
-
-export function findEntryIndex(
-  entries: PluginEntryJson[],
-  token: string,
-): number {
-  return entries.findIndex((entry) => entryMatches(entry, token));
-}
-
-/**
- * Index of an entry with the same identity as `candidate` (same module
- * path or same MCP name) — the duplicate an install must replace.
- */
-export function findConflictIndex(
-  entries: PluginEntryJson[],
-  candidate: PluginEntryJson,
-): number {
-  return entries.findIndex((entry) =>
-    candidate.path !== undefined
-      ? entry.path === candidate.path
-      : entry.name !== undefined && entry.name === candidate.name,
-  );
-}
-
-/**
- * Copy of `entry` with the enabled state applied. Enabled is the default,
- * so enabling removes the key rather than writing `enabled: true`.
- */
-export function withEnabled(
-  entry: PluginEntryJson,
-  enabled: boolean,
-): PluginEntryJson {
-  const { enabled: _drop, ...rest } = entry;
-  return enabled ? rest : { ...rest, enabled: false };
-}
-
-/**
- * Package name of an npm spec, version stripped: `pkg@1.2` → `pkg`,
- * `@scope/pkg@^1` → `@scope/pkg`. A leading `@` is the scope, not a version.
- */
-export function npmSpecName(spec: string): string {
-  const at = spec.lastIndexOf("@");
-  return at > 0 ? spec.slice(0, at) : spec;
-}

package/src/core/agent-runtime/index.ts

@@ -1,62 +0,0 @@
-/**
- * Agent runtime — barrel for the primitives every backend, frontend,
- * and dispatcher consumer reads through. See `agent-runtime/README.md`
- * for the module map.
- *
- *   - `AgentEvent`     + helpers   (events.ts)
- *   - `ModelRef`       + helpers   (model-ref.ts)
- *   - `Backend` + capability interfaces + `composeBackend` (capabilities.ts)
- *   - Backend contract assertions                          (contract-tests.ts)
- */
-
-export {
-  type AgentEvent,
-  type AgentError,
-  type AgentErrorKind,
-  type AgentResult,
-  type UsageSnapshot,
-  addUsage,
-  AgentRunError,
-  classifiedToAgentError,
-  emptyUsage,
-  isAgentEventOf,
-  isAgentRunTerminator,
-  toolInputToRecord,
-} from "./events.js";
-
-export {
-  type BackendId,
-  type CacheSupport,
-  type ModelRef,
-  type ModelSource,
-  BACKEND_IDS,
-  isBackendId,
-  makeBareModelRef,
-  sameModelRef,
-} from "./model-ref.js";
-
-export {
-  type Backend,
-  type BackgroundRunner,
-  type ChatBackend,
-  type ChatRunParams,
-  type ModelCatalog,
-  type SessionBackend,
-  type SystemControl,
-  type ToolRefreshResult,
-  type ToolRuntime,
-  type UsageTelemetry,
-  composeBackend,
-} from "./capabilities.js";
-
-export {
-  assertBackendContract,
-  assertBackendIdentity,
-  assertBackgroundRunnerLifecycle,
-  assertChatBackendEmitsRunStarted,
-  assertChatBackendEmitsSingleUsage,
-  assertChatBackendTerminates,
-  assertCompletedUsageMatchesUsageEvent,
-  assertModelCatalogDefaultShape,
-  assertUsageTelemetryShape,
-} from "./contract-tests.js";

package/src/core/background/index.ts

@@ -1,21 +0,0 @@
-/**
- * Background agents — everything that runs without a user message.
- *
- *   - `heartbeat` — periodic autonomous agent pass ("anything need
- *     doing?"), prompted by prompts/heartbeat.md.
- *   - `dream`    — memory-consolidation agent (daily notes → memory,
- *     mempalace mining), prompted by prompts/dream.md.
- *   - `pulse`    — lightweight liveness/typing-indicator ticker.
- *   - `cron`     — persistent user-scheduled jobs (message / query).
- *   - `triggers` — user-authored watcher scripts that fire wake-ups.
- *
- * All of these drive the backend through the same `BackgroundRunner`
- * surface (core/agent-runtime/capabilities.ts) — they never talk to a
- * concrete backend directly.
- */
-
-export * from "./heartbeat/index.js";
-export * from "./dream.js";
-export * from "./pulse.js";
-export * from "./cron.js";
-export * from "./triggers/index.js";

package/src/core/engine/index.ts

@@ -1,20 +0,0 @@
-/**
- * Engine — the message-flow core.
- *
- *   - `dispatcher`         — per-chat serial, cross-chat parallel turn
- *     execution; the single entry point for "run this user message".
- *   - `gateway`            — loopback HTTP bridge the MCP tool
- *     subprocesses call back into.
- *   - `gateway-actions`    — the action handlers the bridge dispatches
- *     to (send/edit/react/cron/trigger/admin …).
- *   - `backend-controller` — backend lifecycle: init, hot-swap,
- *     cleanup, registry lookup.
- *
- * Everything here is frontend- and backend-agnostic: frontends feed
- * the dispatcher, backends are reached through the agent-runtime
- * capability slots.
- */
-
-export * from "./dispatcher.js";
-export * from "./gateway.js";
-export * from "./backend-controller/index.js";

package/src/core/models/index.ts

@@ -1,17 +0,0 @@
-/**
- * Model layer — everything about "which model is the chat using".
- *
- *   - `catalog`          — model-id resolution, defaults, and the
- *     curated cross-backend catalog.
- *   - `active-model`     — per-chat active-model resolution
- *     (chat-settings → config → backend default).
- *   - `reasoning-levels` — the reasoning-effort vocabulary shared by
- *     every backend (order, labels, normalisation).
- *
- * Presentation helpers (menus, status lines) live in `frontend/` —
- * this layer is pure domain.
- */
-
-export * from "./catalog.js";
-export * from "./active-model.js";
-export * from "./reasoning-levels.js";

package/src/core/soul/index.ts

@@ -1,140 +0,0 @@
-/**
- * Soul Kernel — public surface.
- *
- * Talon's compiled identity: a content-addressed Merkle DAG of evidence, values,
- * spine, reflexes, and lenses, learned mechanically from behavioral telemetry and
- * projected into the system prompt by selection. The reasoning model reads the
- * soul; it never writes it.
- *
- * Typical lifecycle:
- *
- *   const soul = SoulKernel.genesis({ seedValues: [...] });
- *   soul.ingest({ kind: "correction", at, text, activeNodes });
- *   soul.commit("nightly");
- *   const { text } = soul.project({ lens: "dylan" });   // inject `text`
- */
-
-export { SoulKernel } from "./kernel.js";
-export type { GenesisOptions } from "./kernel.js";
-export { SoulDag, structuralChildren } from "./dag.js";
-export { projectRuntime, estimateTokens } from "./projector.js";
-export type { Projection, ProjectionOptions } from "./projector.js";
-export { retrieveValues, DEFAULT_RETRIEVAL_WEIGHTS } from "./retrieve.js";
-export type {
-  RetrievedValue,
-  RetrievalWeights,
-  RetrieveOptions,
-} from "./retrieve.js";
-export {
-  evaluateReflexes,
-  evaluateReflex,
-  isBlocked,
-  seedReflexes,
-  BUILTIN_PREDICATES,
-} from "./reflex.js";
-export type {
-  ReflexContext,
-  ReflexVerdict,
-  ReflexPredicate,
-} from "./reflex.js";
-export {
-  reinforce,
-  coactivate,
-  applyPredictionError,
-  effectiveSalience,
-  confidence,
-  decayFactor,
-} from "./salience.js";
-export { ingest, ingestAll, appendSpine } from "./compiler.js";
-export type { IngestResult } from "./compiler.js";
-export {
-  retrievability,
-  effectiveStrength,
-  reinforceFsrs,
-  nextStability,
-  initialStability,
-} from "./forgetting.js";
-export {
-  critique,
-  extractFeatures,
-  isFlagged,
-  DEFAULT_THRESHOLDS,
-} from "./critic.js";
-export type {
-  Critique,
-  CritiqueFeatures,
-  CritiqueThresholds,
-  FailureMode,
-} from "./critic.js";
-export { deriveFailureModes, assessText } from "./emergent-critic.js";
-export type { EmergentFailureMode, FailureRisk } from "./emergent-critic.js";
-export { emojiValence } from "./signals.js";
-export type { Signal } from "./signals.js";
-export { ValenceModel } from "./valence.js";
-export type { ValenceSnapshot } from "./valence.js";
-export { Adwin } from "./drift.js";
-export type { AdwinChange } from "./drift.js";
-export { diffSnapshots, renderDelta, explainDelta } from "./delta.js";
-export type { SoulDelta } from "./delta.js";
-export { ApprovalQueue } from "./governance.js";
-export type {
-  Proposal,
-  ProposalStatus,
-  ApprovalSnapshot,
-} from "./governance.js";
-export {
-  CompositionalMemory,
-  symbolVector,
-  bind,
-  bundle,
-  permute,
-  cleanup,
-  hdCosine,
-  DEFAULT_HD_DIM,
-} from "./hdc.js";
-export type { Hypervector } from "./hdc.js";
-export {
-  HashingEmbedder,
-  cosineSimilarity,
-  cosineDistance,
-  normalize,
-  centroid,
-  medoidIndex,
-  dot,
-  norm,
-} from "./embedder.js";
-export type { Embedder } from "./embedder.js";
-export { TalonEmbedder } from "./talon-embedder.js";
-export type { TalonEmbedderOptions } from "./talon-embedder.js";
-export {
-  resolveSoulSettings,
-  soulEnabled,
-  DEFAULT_SOUL_SETTINGS,
-} from "./settings.js";
-export type { SoulSettings } from "./settings.js";
-export { clusterEvidence } from "./cluster.js";
-export type { Embedded, EvidenceCluster } from "./cluster.js";
-export { detectTensions, tensionPairs } from "./lattice.js";
-export type { TensionOptions } from "./lattice.js";
-export { associativeRecall, prime } from "./associative.js";
-export type {
-  RecallResult,
-  RecallOptions,
-  PrimeOptions,
-} from "./associative.js";
-export { pagerank } from "./centrality.js";
-export type { PageRankOptions } from "./centrality.js";
-export { consolidate, liveValues, isSuperseded } from "./consolidate.js";
-export type { ConsolidateOptions, ConsolidateResult } from "./consolidate.js";
-export { reflect } from "./reflect.js";
-export { compileLens, liveLens } from "./lens.js";
-export type { LensOptions } from "./lens.js";
-export type { ReflectOptions, ReflectResult } from "./reflect.js";
-export {
-  hashContent,
-  hashPayload,
-  canonicalize,
-  merkleRoot,
-  isHash,
-} from "./hash.js";
-export * from "./types.js";

package/src/core/tools/mcp-server.ts

@@ -1,111 +0,0 @@
-#!/usr/bin/env node
-/**
- * Unified MCP server — replaces per-backend tools.ts files.
- *
- * Reads TALON_FRONTEND env var to compose the right tool set,
- * then registers them all on a single MCP server over stdio.
- *
- * Environment:
- *   TALON_BRIDGE_URL  — HTTP bridge URL (default: http://127.0.0.1:19876)
- *   TALON_CHAT_ID     — Current chat ID
- *   TALON_FRONTEND    — Frontend type: "telegram" | "teams" | "terminal" | "discord" | "native" (default: "telegram")
- */
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { composeTools } from "./index.js";
-import { createBridge, textResult } from "./bridge.js";
-import {
-  ENV_DISABLED_TOOLS,
-  ENV_DISABLED_TOOL_TAGS,
-  parseEnvList,
-} from "./mcp-env.js";
-import type { ToolFrontend, ToolTag } from "./types.js";
-
-process.on("unhandledRejection", (err) => {
-  const detail =
-    err instanceof Error ? (err.stack ?? err.message) : String(err);
-  const message = `[mcp-server] Unhandled rejection: ${detail}\n`;
-
-  // Ensure we always exit even if stderr is backpressured
-  const forceExit = setTimeout(() => process.exit(1), 1000);
-  forceExit.unref();
-
-  process.stderr.write(message, () => {
-    clearTimeout(forceExit);
-    process.exit(1);
-  });
-});
-
-const VALID_FRONTENDS = new Set<ToolFrontend>([
-  "telegram",
-  "teams",
-  "terminal",
-  "discord",
-  "native",
-]);
-const BRIDGE_URL = process.env.TALON_BRIDGE_URL || "http://127.0.0.1:19876";
-const CHAT_ID = process.env.TALON_CHAT_ID || "";
-const rawFrontend = (process.env.TALON_FRONTEND || "telegram") as ToolFrontend;
-
-if (!CHAT_ID) {
-  console.warn(
-    "TALON_CHAT_ID is not set — bridge calls will fail without a valid chat context.",
-  );
-}
-
-if (!VALID_FRONTENDS.has(rawFrontend)) {
-  console.error(
-    `Invalid TALON_FRONTEND: "${rawFrontend}". Must be one of: ${[...VALID_FRONTENDS].join(", ")}`,
-  );
-  process.exit(1);
-}
-const FRONTEND = rawFrontend;
-
-const bridge = createBridge(BRIDGE_URL, CHAT_ID);
-const serverName = `${FRONTEND}-tools`;
-const server = new McpServer({ name: serverName, version: "3.0.0" });
-
-// Compose and register the tool set for the active frontend, minus
-// any config-disabled tools/tags (see `disabledTools` /
-// `disabledToolTags` in talon.json — every registered tool costs
-// context tokens in every session, so unused groups are trimmable).
-// `end_turn` is exempt: tool-only backends need it to close every turn.
-const excludeNames = parseEnvList(process.env[ENV_DISABLED_TOOLS]).filter(
-  (name) => name !== "end_turn",
-);
-const excludeTags = parseEnvList(
-  process.env[ENV_DISABLED_TOOL_TAGS],
-) as ToolTag[];
-
-const tools = composeTools({ frontend: FRONTEND, excludeTags, excludeNames });
-if (excludeTags.length > 0 && !tools.some((t) => t.name === "end_turn")) {
-  const endTurn = composeTools({ frontend: FRONTEND }).find(
-    (t) => t.name === "end_turn",
-  );
-  if (endTurn) tools.push(endTurn);
-}
-
-for (const tool of tools) {
-  server.tool(tool.name, tool.description, tool.schema, async (params) =>
-    textResult(await tool.execute(params, bridge)),
-  );
-}
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-
-  // Graceful self-termination: when the parent closes our stdin (e.g. the SDK
-  // tears down this MCP server during hot-swap), exit cleanly. This is the
-  // OS-agnostic replacement for scanning /proc — the parent signals "you're done"
-  // by closing the stdio pipe, and we respect it.
-  process.stdin.on("end", () => {
-    server.close().finally(() => process.exit(0));
-  });
-}
-
-main().catch((err) => {
-  console.error("MCP server error:", err);
-  process.exit(1);
-});