@tangle-network/agent-runtime 0.16.1 → 0.17.1

package/dist/index.js

@@ -420,102 +420,6 @@ function stringValue(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 
-// src/chat-turn.ts
-import { mergeAgentProfiles } from "@tangle-network/sandbox";
-var RUNTIME_PATH = "/runtime/agents/run/stream";
-async function* runChatTurn(options) {
-  const turnProfile = options.overlay ? composeTurnProfile(options.profile, options.overlay) : options.profile;
-  const url = `${options.sandbox.runtimeUrl}${RUNTIME_PATH}`;
-  const backendType = turnProfile.metadata?.backend?.type ?? "claude-code";
-  const body = JSON.stringify({
-    backend: {
-      type: backendType,
-      profile: turnProfile,
-      ...options.modelOverride ? { model: { default: options.modelOverride } } : {}
-    },
-    messages: [...options.priorMessages, { role: "user", content: options.message }]
-  });
-  const headers = {
-    "Content-Type": "application/json",
-    Accept: "text/event-stream"
-  };
-  if (options.sandbox.authHeader) {
-    headers[options.sandbox.authHeader.name] = options.sandbox.authHeader.value;
-  }
-  const fetchImpl = options.fetch ?? fetch;
-  const response = await fetchImpl(url, {
-    method: "POST",
-    headers,
-    body,
-    signal: options.signal
-  });
-  if (!response.ok || !response.body) {
-    const text = response.body ? await response.text() : "";
-    throw new ChatTurnError(
-      `runChatTurn: sandbox returned ${response.status} ${response.statusText}: ${text.slice(0, 500)}`,
-      response.status
-    );
-  }
-  yield* parseSseStream(response.body);
-}
-function composeTurnProfile(base, overlay) {
-  const partial = {};
-  if (overlay.promptOverlay) partial.prompt = overlay.promptOverlay;
-  if (overlay.resourcesOverlay) partial.resources = overlay.resourcesOverlay;
-  if (overlay.subagentsOverlay) partial.subagents = overlay.subagentsOverlay;
-  if (overlay.metadata) partial.metadata = overlay.metadata;
-  return mergeAgentProfiles(base, partial) ?? base;
-}
-async function* parseSseStream(stream) {
-  const decoder = new TextDecoder();
-  const reader = stream.getReader();
-  let buffer = "";
-  try {
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      let idx = buffer.indexOf("\n");
-      while (idx >= 0) {
-        const line = buffer.slice(0, idx).replace(/\r$/, "").trim();
-        buffer = buffer.slice(idx + 1);
-        idx = buffer.indexOf("\n");
-        if (!line) continue;
-        const payload = line.startsWith("data:") ? line.slice(5).trim() : line;
-        if (payload === "[DONE]" || payload === "") continue;
-        try {
-          const parsed = JSON.parse(payload);
-          yield parsed;
-        } catch {
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-var ChatTurnError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "ChatTurnError";
-  }
-  status;
-};
-function sandboxAsChatTurnTarget(instance, opts) {
-  const base = instance.url ?? instance.connection?.runtimeUrl ?? "";
-  if (!base) {
-    throw new ChatTurnError(
-      `sandboxAsChatTurnTarget: SandboxInstance has neither .url nor .connection.runtimeUrl set`
-    );
-  }
-  return {
-    id: instance.id,
-    runtimeUrl: base.replace(/\/+$/, ""),
-    authHeader: opts?.authHeader
-  };
-}
-
 // src/durable/chat-engine.ts
 var encoder = new TextEncoder();
 function encodeLine(event) {
@@ -608,77 +512,6 @@ function deriveExecutionId(input) {
   return `${input.projectId}:${input.sessionId}:${input.turnIndex}`;
 }
 
-// src/intent-router.ts
-var DEFAULT_PATTERN_WEIGHT = 1.5;
-var DEFAULT_MIN_SCORE = 1;
-function isMatcher(value) {
-  if (!value || typeof value !== "object") return false;
-  const v = value;
-  return Array.isArray(v.keywords) || Array.isArray(v.patterns) || typeof v.minScore === "number";
-}
-function readMatcher(subagent) {
-  const m = subagent.metadata;
-  if (!m) return null;
-  const raw = m.matchers ?? m.matcher ?? null;
-  if (!raw) return null;
-  if (Array.isArray(raw)) {
-    const merged = { keywords: [], patterns: [], minScore: DEFAULT_MIN_SCORE };
-    for (const entry of raw) {
-      if (!isMatcher(entry)) continue;
-      merged.keywords = [...merged.keywords ?? [], ...entry.keywords ?? []];
-      merged.patterns = [...merged.patterns ?? [], ...entry.patterns ?? []];
-      if (entry.minScore !== void 0) merged.minScore = entry.minScore;
-    }
-    return merged;
-  }
-  if (isMatcher(raw)) return raw;
-  return null;
-}
-function classifyIntent(profile, message, opts = {}) {
-  const lower = message.toLowerCase();
-  const subagents = profile.subagents ?? {};
-  const skip = new Set(opts.skip ?? []);
-  const defaultMinScore = opts.defaultMinScore ?? DEFAULT_MIN_SCORE;
-  const scores = {};
-  const evaluated = {};
-  let bestId = null;
-  let bestScore = -Infinity;
-  let bestSubagent = null;
-  for (const [id, subagent] of Object.entries(subagents)) {
-    if (skip.has(id)) continue;
-    if (opts.filter && !opts.filter(subagent, id)) continue;
-    const matcher = readMatcher(subagent);
-    if (!matcher) {
-      evaluated[id] = { keywordHits: 0, patternHits: 0, minScore: defaultMinScore };
-      scores[id] = 0;
-      continue;
-    }
-    const weight = matcher.weight ?? 1;
-    let kHits = 0;
-    for (const kw of matcher.keywords ?? []) {
-      if (kw && lower.includes(kw.toLowerCase())) kHits += 1;
-    }
-    let pHits = 0;
-    for (const p of matcher.patterns ?? []) {
-      const re = p instanceof RegExp ? p : new RegExp(p, "i");
-      if (re.test(message)) pHits += 1;
-    }
-    const score = kHits * weight + pHits * DEFAULT_PATTERN_WEIGHT * weight;
-    const minScore = matcher.minScore ?? defaultMinScore;
-    scores[id] = score;
-    evaluated[id] = { keywordHits: kHits, patternHits: pHits, minScore };
-    if (score >= minScore && score > bestScore) {
-      bestScore = score;
-      bestId = id;
-      bestSubagent = subagent;
-    }
-  }
-  if (bestId === null) {
-    return { id: null, subagent: null, score: 0, scores, evaluated };
-  }
-  return { id: bestId, subagent: bestSubagent, score: bestScore, scores, evaluated };
-}
-
 // src/model-resolution.ts
 var DEFAULT_ROUTER_BASE_URL = "https://router.tangle.tools";
 function resolveRouterBaseUrl(env = {}) {
@@ -692,22 +525,6 @@ async function getModels(routerBaseUrl = DEFAULT_ROUTER_BASE_URL) {
   const body = await res.json();
   return Array.isArray(body.data) ? body.data : [];
 }
-function withConfiguredModels(models, extraIds) {
-  const known = new Set(models.map((model) => model.id));
-  const extra = extraIds.map((id) => cleanModelId(id)).filter((id) => id !== void 0 && !known.has(id)).map(
-    (id) => ({
-      id,
-      name: id,
-      description: "Configured chat model for this environment.",
-      architecture: {
-        modality: "text->text",
-        input_modalities: ["text"],
-        output_modalities: ["text"]
-      }
-    })
-  );
-  return extra.length > 0 ? [...extra, ...models] : models;
-}
 function cleanModelId(value) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
@@ -758,112 +575,6 @@ async function validateChatModelId(modelId, options = {}) {
   return { succeeded: true, value: cleaned };
 }
 
-// src/profile-conformance.ts
-var DEFAULT_SHELL_CAPS = [
-  "bash",
-  "sh",
-  "python",
-  "node",
-  "curl",
-  "web",
-  "browser",
-  "shell"
-];
-var DEFAULT_MIN_PROMPT_CHARS = 800;
-function checkSystemPrompt(profile, minChars) {
-  const prompt = profile.prompt?.systemPrompt;
-  if (!prompt || prompt.trim().length < minChars) {
-    return [
-      {
-        severity: "error",
-        code: "system-prompt-too-short",
-        path: "prompt.systemPrompt",
-        message: `prompt.systemPrompt is ${prompt?.length ?? 0} chars; min required is ${minChars}. Profiles below this threshold are almost always placeholders.`
-      }
-    ];
-  }
-  return [];
-}
-function checkToolsVsMcp(profile, opts) {
-  const issues = [];
-  const shellCaps = new Set(opts.knownShellCapabilities ?? DEFAULT_SHELL_CAPS);
-  const allowedWithoutMcp = new Set(opts.toolsAllowedWithoutMcp ?? []);
-  const tools = profile.tools ?? {};
-  const mcp = profile.mcp ?? {};
-  for (const [name, value] of Object.entries(tools)) {
-    if (shellCaps.has(name)) {
-      issues.push({
-        severity: "error",
-        code: "shell-capability-as-tool",
-        path: `tools.${name}`,
-        message: `'${name}' is a shell capability, not a tool. Move to permissions and remove from tools.`
-      });
-      continue;
-    }
-    if (allowedWithoutMcp.has(name)) continue;
-    if (value === false) continue;
-    if (!mcp[name]) {
-      issues.push({
-        severity: "error",
-        code: "decorative-tool-without-mcp",
-        path: `tools.${name}`,
-        message: `'${name}' declared in tools but no corresponding mcp[${name}] AgentProfileMcpServer. Either wire an MCP server, list this name in toolsAllowedWithoutMcp (if it's a file-mounted CLI binary), or remove from tools.`
-      });
-    }
-  }
-  return issues;
-}
-function checkSubagentShape(subagent, id) {
-  const issues = [];
-  if (!subagent.description || subagent.description.trim().length < 40) {
-    issues.push({
-      severity: "error",
-      code: "subagent-description-too-short",
-      path: `subagents.${id}.description`,
-      message: `subagents.${id}.description is missing or too short. Required for routing UX + audit trail.`
-    });
-  }
-  if (!subagent.prompt || subagent.prompt.trim().length < 100) {
-    issues.push({
-      severity: "error",
-      code: "subagent-prompt-too-short",
-      path: `subagents.${id}.prompt`,
-      message: `subagents.${id}.prompt is missing or below 100 chars. Either ship the specialist prompt or move this subagent under metadata.plannedSubagents.`
-    });
-  }
-  return issues;
-}
-function checkScaffoldSubagents(profile, strict) {
-  const issues = [];
-  const subagents = profile.subagents ?? {};
-  for (const [id, subagent] of Object.entries(subagents)) {
-    const meta = subagent.metadata;
-    const status = meta?.status;
-    if (status === "scaffold" || status === "not-implemented" || meta?.implemented === false) {
-      issues.push({
-        severity: strict ? "error" : "warn",
-        code: "subagent-scaffold-shipped",
-        path: `subagents.${id}`,
-        message: `subagents.${id} is a scaffold (metadata.status='${status}'). Router must gate on metadata.status === 'full' OR caller must opt into scaffolds explicitly.`
-      });
-    }
-  }
-  return issues;
-}
-function assertProfileConformance(profile, opts = {}) {
-  const issues = [
-    ...checkSystemPrompt(profile, opts.minSystemPromptChars ?? DEFAULT_MIN_PROMPT_CHARS),
-    ...checkToolsVsMcp(profile, opts),
-    ...checkScaffoldSubagents(profile, opts.strictNoScaffolds ?? false)
-  ];
-  for (const [id, subagent] of Object.entries(profile.subagents ?? {})) {
-    issues.push(...checkSubagentShape(subagent, id));
-  }
-  const errors = issues.filter((i) => i.severity === "error");
-  const warnings = issues.filter((i) => i.severity === "warn");
-  return { valid: errors.length === 0, errors, warnings };
-}
-
 // src/readiness.ts
 var DEFAULT_MINIMUM_READINESS_SCORE = 0.7;
 function decideKnowledgeReadiness(report, options = {}) {
@@ -1009,29 +720,6 @@ async function runAgentTask(options) {
     )
   };
 }
-function summarizeAgentTaskRun(result) {
-  return {
-    taskId: result.task.id,
-    domain: result.task.domain,
-    status: result.status,
-    reason: result.control.reason,
-    readinessStatus: decideKnowledgeReadiness(result.knowledge).status,
-    readinessScore: result.knowledge.readinessScore,
-    recommendedAction: result.knowledge.recommendedAction,
-    blockingGapIds: result.knowledge.blockingMissingRequirements.map(
-      (requirement) => requirement.id
-    ),
-    nonBlockingGapIds: result.knowledge.nonBlockingGaps.map((requirement) => requirement.id),
-    questionCount: result.questions.length,
-    acquisitionPlanCount: result.acquisitionPlans.length,
-    acquiredEvidenceCount: result.acquiredEvidenceIds.length,
-    controlStepCount: result.control.steps.length,
-    pass: result.control.pass,
-    failureClass: result.control.failureClass,
-    wallMs: result.control.wallMs,
-    costUsd: result.control.spentCostUsd
-  };
-}
 async function* runAgentTaskStream(options) {
   const task = options.task;
   const input = { task, ...options.input ?? {} };
@@ -1767,222 +1455,23 @@ function runtimeStreamServerSentEvent(event, options = {}) {
 function stripNewlines(value) {
   return value.replace(/[\r\n]/g, " ");
 }
-
-// src/trace-bridge.ts
-function createTraceBridge(options) {
-  if (!options.runId) {
-    throw new ValidationError("createTraceBridge: runId is required");
-  }
-  let counter = 0;
-  const newEventId = options.newEventId ?? (() => `evt-${++counter}`);
-  const baseSpanId = options.spanId;
-  const toTraceEvent = (event) => {
-    const projection = projectToTraceEvent(event);
-    if (!projection) return void 0;
-    return {
-      eventId: newEventId(),
-      runId: options.runId,
-      spanId: baseSpanId,
-      kind: projection.kind,
-      timestamp: timestampFor(event),
-      payload: projection.payload
-    };
-  };
-  return {
-    toTraceEvent,
-    drain(events) {
-      const out = [];
-      for (const event of events) {
-        const trace = toTraceEvent(event);
-        if (trace) out.push(trace);
-      }
-      return out;
-    }
-  };
-}
-function toAgentEvalTrace(event, options) {
-  return createTraceBridge(options).toTraceEvent(event);
-}
-function projectToTraceEvent(event) {
-  switch (event.type) {
-    case "task_start":
-      return {
-        kind: "log",
-        payload: { phase: "task_start", taskId: event.task.id, intent: event.task.intent }
-      };
-    case "readiness_start":
-      return { kind: "log", payload: { phase: "readiness_start", taskId: event.task.id } };
-    case "readiness_end":
-      return {
-        kind: event.decision.passed ? "log" : "policy_violation",
-        payload: {
-          phase: "readiness_end",
-          taskId: event.task.id,
-          status: event.decision.status,
-          readinessScore: event.decision.readinessScore,
-          blockingGapIds: event.decision.blockingGapIds,
-          nonBlockingGapIds: event.decision.nonBlockingGapIds,
-          reason: event.decision.reason
-        }
-      };
-    case "questions_start":
-      return {
-        kind: "log",
-        payload: { phase: "questions_start", questionCount: event.questions.length }
-      };
-    case "questions_end":
-      return {
-        kind: "log",
-        payload: {
-          phase: "questions_end",
-          questionCount: event.questions.length,
-          answerCount: Object.keys(event.userAnswers).length
-        }
-      };
-    case "acquisition_start":
-      return {
-        kind: "log",
-        payload: { phase: "acquisition_start", planCount: event.acquisitionPlans.length }
-      };
-    case "acquisition_end":
-      return {
-        kind: "log",
-        payload: {
-          phase: "acquisition_end",
-          planCount: event.acquisitionPlans.length,
-          evidenceCount: event.acquiredEvidenceIds.length
-        }
-      };
-    case "session_created":
-    case "session_resumed":
-      return {
-        kind: "log",
-        payload: {
-          phase: event.type,
-          sessionId: event.session.id,
-          backend: event.session.backend
-        }
-      };
-    case "backend_start":
-    case "backend_end":
-      return { kind: "log", payload: { phase: event.type, backend: event.backend } };
-    case "backend_error":
-      return {
-        kind: "error",
-        payload: {
-          backend: event.backend,
-          message: event.message,
-          recoverable: event.recoverable
-        }
-      };
-    case "tool_call":
-      return {
-        kind: "log",
-        payload: {
-          phase: "tool_call",
-          toolName: event.toolName,
-          toolCallId: event.toolCallId
-          // Args omitted — trace events are point-in-time markers, not the
-          // canonical store for tool I/O. Attach payloads to a `ToolSpan`
-          // when retention is required.
-        }
-      };
-    case "tool_result":
-      return {
-        kind: "log",
-        payload: {
-          phase: "tool_result",
-          toolName: event.toolName,
-          toolCallId: event.toolCallId
-        }
-      };
-    case "llm_call":
-      return {
-        kind: "log",
-        payload: {
-          phase: "llm_call",
-          model: event.model,
-          tokensIn: event.tokensIn,
-          tokensOut: event.tokensOut,
-          costUsd: event.costUsd,
-          latencyMs: event.latencyMs,
-          finishReason: event.finishReason
-        }
-      };
-    case "artifact":
-      return {
-        kind: "state_mutation",
-        payload: {
-          phase: "artifact",
-          artifactId: event.artifactId,
-          name: event.name,
-          mimeType: event.mimeType
-        }
-      };
-    case "proposal_created":
-      return {
-        kind: "state_mutation",
-        payload: {
-          phase: "proposal_created",
-          proposalId: event.proposalId,
-          title: event.title,
-          status: event.status
-        }
-      };
-    case "task_end":
-      return {
-        kind: event.status === "failed" || event.status === "aborted" ? "error" : "log",
-        payload: { phase: "task_end", status: event.status, reason: event.reason }
-      };
-    case "final":
-      return {
-        kind: event.status === "failed" || event.status === "aborted" ? "error" : "log",
-        payload: { phase: "final", status: event.status, reason: event.reason }
-      };
-    case "text_delta":
-    case "reasoning_delta":
-      return void 0;
-    default: {
-      const exhaust = event;
-      void exhaust;
-      return void 0;
-    }
-  }
-}
-function timestampFor(event) {
-  const iso = "timestamp" in event ? event.timestamp : void 0;
-  if (!iso) return Date.now();
-  const parsed = Date.parse(iso);
-  return Number.isFinite(parsed) ? parsed : Date.now();
-}
 export {
   AgentEvalError2 as AgentEvalError,
-  BackendTransportError,
-  CaptureIntegrityError,
-  ChatTurnError,
   ConfigError,
   DEFAULT_ROUTER_BASE_URL,
   InMemoryRuntimeSessionStore,
   JudgeError,
   NotFoundError,
-  ReplayError,
   RuntimeRunStateError,
-  SessionMismatchError,
   ValidationError,
-  VerificationError,
-  assertProfileConformance,
-  classifyIntent,
   cleanModelId,
-  composeTurnProfile,
   createIterableBackend,
   createOpenAICompatibleBackend,
   createRuntimeEventCollector,
   createRuntimeStreamEventCollector,
   createSandboxPromptBackend,
-  createTraceBridge,
   decideKnowledgeReadiness,
   deriveExecutionId,
-  encodeServerSentEvent,
   getModels,
   handleChatTurn,
   readinessServerSentEvent,
@@ -1990,16 +1479,11 @@ export {
   resolveRouterBaseUrl,
   runAgentTask,
   runAgentTaskStream,
-  runChatTurn,
   runtimeStreamServerSentEvent,
-  sandboxAsChatTurnTarget,
   sanitizeAgentRuntimeEvent,
   sanitizeKnowledgeReadinessReport,
   sanitizeRuntimeStreamEvent,
   startRuntimeRun,
-  summarizeAgentTaskRun,
-  toAgentEvalTrace,
-  validateChatModelId,
-  withConfiguredModels
+  validateChatModelId
 };
 //# sourceMappingURL=index.js.map