@tangle-network/agent-runtime 0.4.3 → 0.5.1

package/dist/index.js

@@ -6,6 +6,24 @@ import {
   scoreKnowledgeReadiness,
   userQuestionsForKnowledgeGaps
 } from "@tangle-network/agent-eval";
+var InMemoryRuntimeSessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  events = /* @__PURE__ */ new Map();
+  get(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  put(session) {
+    this.sessions.set(session.id, session);
+  }
+  appendEvent(sessionId, event) {
+    const existing = this.events.get(sessionId) ?? [];
+    existing.push(event);
+    this.events.set(sessionId, existing);
+  }
+  listEvents(sessionId) {
+    return [...this.events.get(sessionId) ?? []];
+  }
+};
 async function runAgentTask(options) {
   const task = options.task;
   await emit(options.onEvent, { type: "task_start", task });
@@ -95,6 +113,95 @@ function summarizeAgentTaskRun(result) {
     costUsd: result.control.spentCostUsd
   };
 }
+async function* runAgentTaskStream(options) {
+  const task = options.task;
+  const input = { task, ...options.input ?? {} };
+  const started = streamEvent({ type: "task_start", task });
+  yield started;
+  const readinessStart = streamEvent({ type: "readiness_start", task });
+  yield readinessStart;
+  let knowledge = await buildReadiness(task, options.knowledge);
+  const questions = userQuestionsForKnowledgeGaps(knowledge.blockingMissingRequirements);
+  const acquisitionPlans = acquisitionPlansForKnowledgeGaps([
+    ...knowledge.blockingMissingRequirements,
+    ...knowledge.nonBlockingGaps
+  ]);
+  const preflight = await runKnowledgePreflightStream(task, questions, acquisitionPlans, options.knowledge);
+  for (const event of preflight.events) yield event;
+  if (options.knowledge?.refreshReadiness && (Object.keys(preflight.userAnswers).length > 0 || preflight.acquiredEvidenceIds.length > 0)) {
+    yield streamEvent({ type: "readiness_start", task });
+    knowledge = await options.knowledge.refreshReadiness({
+      task,
+      previous: knowledge,
+      userAnswers: preflight.userAnswers,
+      acquiredEvidenceIds: preflight.acquiredEvidenceIds
+    });
+  }
+  const decision = decideKnowledgeReadiness(knowledge, { minimumScore: options.minimumReadinessScore });
+  yield streamEvent({ type: "readiness_end", task, knowledge, decision });
+  if (!decision.passed && decision.status === "blocked") {
+    const reason = `knowledge readiness blocked: ${decision.reason}`;
+    yield streamEvent({ type: "task_end", task, status: "blocked", reason });
+    yield streamEvent({ type: "final", task, status: "blocked", reason });
+    return;
+  }
+  const store = options.sessionStore;
+  const existing = options.sessionId ? await store?.get(options.sessionId) : void 0;
+  const shouldResume = Boolean(options.resume && existing);
+  let session = shouldResume && existing ? await resumeBackendSession(options.backend, existing, input, { task, knowledge, signal: options.signal }) : await startBackendSession(options.backend, input, { task, knowledge, signal: options.signal }, options.sessionId);
+  await store?.put(session);
+  const sessionEvent = streamEvent({
+    type: shouldResume ? "session_resumed" : "session_created",
+    task,
+    session
+  });
+  await store?.appendEvent?.(session.id, sessionEvent);
+  yield sessionEvent;
+  const backendStart = streamEvent({ type: "backend_start", task, session, backend: options.backend.kind });
+  await store?.appendEvent?.(session.id, backendStart);
+  yield backendStart;
+  let finalText = "";
+  try {
+    for await (const rawEvent of options.backend.stream(input, { task, knowledge, session, signal: options.signal })) {
+      const event = normalizeBackendStreamEvent(rawEvent, task, session);
+      if (event.type === "text_delta") finalText += event.text;
+      await store?.appendEvent?.(session.id, event);
+      yield event;
+    }
+    const completedStatus = "completed";
+    session = touchSession({ ...session, status: completedStatus });
+    await store?.put(session);
+    const backendEnd = streamEvent({ type: "backend_end", task, session, backend: options.backend.kind });
+    await store?.appendEvent?.(session.id, backendEnd);
+    yield backendEnd;
+    const reason = "backend completed";
+    const taskEnd = streamEvent({ type: "task_end", task, status: completedStatus, reason });
+    await store?.appendEvent?.(session.id, taskEnd);
+    yield taskEnd;
+    const final = streamEvent({ type: "final", task, session, status: completedStatus, reason, text: finalText || void 0 });
+    await store?.appendEvent?.(session.id, final);
+    yield final;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    session = touchSession({ ...session, status: options.signal?.aborted ? "aborted" : "failed" });
+    await store?.put(session);
+    const backendError = streamEvent({
+      type: "backend_error",
+      task,
+      session,
+      backend: options.backend.kind,
+      message,
+      recoverable: !options.signal?.aborted
+    });
+    await store?.appendEvent?.(session.id, backendError);
+    yield backendError;
+    const status = options.signal?.aborted ? "aborted" : "failed";
+    const taskEnd = streamEvent({ type: "task_end", task, status, reason: message });
+    await store?.appendEvent?.(session.id, taskEnd);
+    yield taskEnd;
+    yield streamEvent({ type: "final", task, session, status, reason: message, text: finalText || void 0 });
+  }
+}
 function decideKnowledgeReadiness(report, options = {}) {
   const minimumScore = options.minimumScore ?? 0.7;
   const blockingGapIds = report.blockingMissingRequirements.map((requirement) => requirement.id);
@@ -189,6 +296,98 @@ function sanitizeAgentRuntimeEvent(event, options = {}) {
   }
   return { ...base, status: event.status, reason: event.reason };
 }
+function sanitizeRuntimeStreamEvent(event, options = {}) {
+  const withTask = "task" in event && event.task ? { task: sanitizeTask(event.task, options) } : {};
+  const withSession = "session" in event && event.session ? { session: sanitizeRuntimeSession(event.session, options) } : {};
+  if (event.type === "readiness_end") {
+    return {
+      type: event.type,
+      ...withTask,
+      timestamp: event.timestamp,
+      decision: event.decision,
+      knowledge: sanitizeKnowledgeReadinessReport(event.knowledge, options)
+    };
+  }
+  if (event.type === "questions_start") {
+    return { type: event.type, ...withTask, timestamp: event.timestamp, questions: event.questions.map((question) => sanitizeQuestion(question, options)) };
+  }
+  if (event.type === "questions_end") {
+    return {
+      type: event.type,
+      ...withTask,
+      timestamp: event.timestamp,
+      questions: event.questions.map((question) => sanitizeQuestion(question, options)),
+      userAnswers: options.includeUserAnswers ? event.userAnswers : redactRecord(event.userAnswers)
+    };
+  }
+  if (event.type === "acquisition_start") {
+    return { type: event.type, ...withTask, timestamp: event.timestamp, acquisitionPlans: event.acquisitionPlans.map(sanitizeAcquisitionPlan) };
+  }
+  if (event.type === "acquisition_end") {
+    return {
+      type: event.type,
+      ...withTask,
+      timestamp: event.timestamp,
+      acquisitionPlans: event.acquisitionPlans.map(sanitizeAcquisitionPlan),
+      acquiredEvidenceCount: event.acquiredEvidenceIds.length,
+      acquiredEvidenceIds: options.includeEvidenceIds ? event.acquiredEvidenceIds : void 0
+    };
+  }
+  if (event.type === "tool_call") {
+    return {
+      type: event.type,
+      ...withTask,
+      ...withSession,
+      timestamp: event.timestamp,
+      toolName: event.toolName,
+      toolCallId: event.toolCallId,
+      args: options.includeControlPayloads ? event.args : void 0
+    };
+  }
+  if (event.type === "tool_result") {
+    return {
+      type: event.type,
+      ...withTask,
+      ...withSession,
+      timestamp: event.timestamp,
+      toolName: event.toolName,
+      toolCallId: event.toolCallId,
+      result: options.includeControlPayloads ? event.result : void 0
+    };
+  }
+  if (event.type === "artifact") {
+    return {
+      type: event.type,
+      ...withTask,
+      ...withSession,
+      timestamp: event.timestamp,
+      artifactId: event.artifactId,
+      name: event.name,
+      mimeType: event.mimeType,
+      uri: options.includeEvidenceIds ? event.uri : void 0,
+      metadata: options.includeMetadata ? event.metadata : void 0
+    };
+  }
+  if (event.type === "final") {
+    return {
+      type: event.type,
+      ...withTask,
+      ...withSession,
+      timestamp: event.timestamp,
+      status: event.status,
+      reason: event.reason,
+      text: options.includeControlPayloads ? event.text : void 0,
+      metadata: options.includeMetadata ? event.metadata : void 0
+    };
+  }
+  return {
+    type: event.type,
+    ...withTask,
+    ...withSession,
+    timestamp: "timestamp" in event ? event.timestamp : void 0,
+    ...pickPublicStreamFields(event)
+  };
+}
 function createRuntimeEventCollector(options = {}) {
   const events = [];
   return {
@@ -220,6 +419,93 @@ function readinessServerSentEvent(report, options = {}) {
     readiness: sanitizeKnowledgeReadinessReport(report, telemetryOptions)
   }, { event, id, retry });
 }
+function runtimeStreamServerSentEvent(event, options = {}) {
+  const { event: sseEvent, id, retry, ...telemetryOptions } = options;
+  return encodeServerSentEvent(sanitizeRuntimeStreamEvent(event, telemetryOptions), { event: sseEvent, id, retry });
+}
+function createIterableBackend(options) {
+  return options;
+}
+function createSandboxPromptBackend(options) {
+  return {
+    kind: options.kind ?? "sandbox",
+    async start(input, context) {
+      const box = await options.getBox(input, context);
+      return newRuntimeSession(options.kind ?? "sandbox", options.getSessionId?.(box, input) ?? context.requestedSessionId, {
+        resumable: true
+      });
+    },
+    resume(session) {
+      return touchSession({ ...session, status: "active" });
+    },
+    async *stream(input, context) {
+      const box = await options.getBox(input, context);
+      const message = input.message ?? input.messages?.at(-1)?.content ?? context.task.intent;
+      for await (const event of options.streamPrompt(box, message, context)) {
+        const mapped = options.mapEvent?.(event, context) ?? mapCommonBackendEvent(event, context);
+        if (mapped) yield mapped;
+      }
+    }
+  };
+}
+function createCliBridgeBackend(options) {
+  const fetcher = options.fetchImpl ?? fetch;
+  return {
+    kind: options.kind ?? "cli-bridge",
+    start(_input, context) {
+      return newRuntimeSession(options.kind ?? "cli-bridge", context.requestedSessionId, { resumable: true });
+    },
+    resume(session) {
+      return touchSession({ ...session, status: "active" });
+    },
+    async *stream(input, context) {
+      const response = await fetcher(options.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...options.bearer ? { Authorization: `Bearer ${options.bearer}` } : {}
+        },
+        body: JSON.stringify({
+          sessionId: context.session.id,
+          resumeToken: context.session.resumeToken,
+          task: input.task,
+          message: input.message,
+          messages: input.messages,
+          inputs: input.inputs
+        }),
+        signal: context.signal
+      });
+      if (!response.ok) throw new Error(`cli bridge returned ${response.status}`);
+      yield* streamResponseEvents(response, context);
+    }
+  };
+}
+function createOpenAICompatibleBackend(options) {
+  const fetcher = options.fetchImpl ?? fetch;
+  return {
+    kind: options.kind ?? "tcloud",
+    start(_input, context) {
+      return newRuntimeSession(options.kind ?? "tcloud", context.requestedSessionId);
+    },
+    async *stream(input, context) {
+      const response = await fetcher(`${options.baseUrl.replace(/\/$/, "")}/chat/completions`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${options.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: options.model,
+          stream: true,
+          messages: input.messages ?? [{ role: "user", content: input.message ?? context.task.intent }]
+        }),
+        signal: context.signal
+      });
+      if (!response.ok) throw new Error(`chat backend returned ${response.status}`);
+      yield* streamResponseEvents(response, context);
+    }
+  };
+}
 async function runKnowledgePreflight(task, questions, acquisitionPlans, provider, onEvent) {
   let userAnswers = {};
   let acquiredEvidenceIds = [];
@@ -235,6 +521,22 @@ async function runKnowledgePreflight(task, questions, acquisitionPlans, provider
   }
   return { userAnswers, acquiredEvidenceIds };
 }
+async function runKnowledgePreflightStream(task, questions, acquisitionPlans, provider) {
+  const events = [];
+  let userAnswers = {};
+  let acquiredEvidenceIds = [];
+  if (questions.length > 0 && provider?.answerQuestions) {
+    events.push(streamEvent({ type: "questions_start", task, questions }));
+    userAnswers = await provider.answerQuestions(questions, task);
+    events.push(streamEvent({ type: "questions_end", task, questions, userAnswers }));
+  }
+  if (acquisitionPlans.length > 0 && provider?.executeAcquisitionPlans) {
+    events.push(streamEvent({ type: "acquisition_start", task, acquisitionPlans }));
+    acquiredEvidenceIds = await provider.executeAcquisitionPlans(acquisitionPlans, task);
+    events.push(streamEvent({ type: "acquisition_end", task, acquisitionPlans, acquiredEvidenceIds }));
+  }
+  return { userAnswers, acquiredEvidenceIds, events };
+}
 function sanitizeTask(task, options) {
   return {
     id: task.id,
@@ -247,6 +549,17 @@ function sanitizeTask(task, options) {
     metadata: options.includeMetadata ? task.metadata : task.metadata ? "[redacted]" : void 0
   };
 }
+function sanitizeRuntimeSession(session, options) {
+  return {
+    id: session.id,
+    backend: session.backend,
+    status: session.status,
+    hasResumeToken: Boolean(session.resumeToken),
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    metadata: options.includeMetadata ? session.metadata : session.metadata ? "[redacted]" : void 0
+  };
+}
 function sanitizeKnowledgeRequirement(requirement, options) {
   const includeDescription = options.includeRequirementDescriptions && requirement.sensitivity !== "secret";
   return {
@@ -337,6 +650,135 @@ function redactRecord(record) {
 function stripNewlines(value) {
   return value.replace(/[\r\n]/g, " ");
 }
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function streamEvent(event) {
+  return { ...event, timestamp: timestamp() };
+}
+function newRuntimeSession(backend, requestedId, metadata) {
+  const now = timestamp();
+  return {
+    id: requestedId || crypto.randomUUID(),
+    backend,
+    status: "active",
+    createdAt: now,
+    updatedAt: now,
+    metadata
+  };
+}
+function touchSession(session) {
+  return { ...session, updatedAt: timestamp() };
+}
+async function startBackendSession(backend, input, context, requestedSessionId) {
+  if (backend.start) return backend.start(input, { ...context, requestedSessionId });
+  return newRuntimeSession(backend.kind, requestedSessionId);
+}
+async function resumeBackendSession(backend, session, input, context) {
+  if (session.backend !== backend.kind) {
+    throw new Error(`Cannot resume ${session.backend} session with ${backend.kind} backend`);
+  }
+  if (backend.resume) return backend.resume(session, input, context);
+  return touchSession({ ...session, status: "active" });
+}
+function normalizeBackendStreamEvent(event, task, session) {
+  if ("task" in event && event.task && "session" in event && event.session && "timestamp" in event && event.timestamp) return event;
+  return {
+    ...event,
+    task: "task" in event && event.task ? event.task : task,
+    session: "session" in event && event.session ? event.session : session,
+    timestamp: "timestamp" in event && event.timestamp ? event.timestamp : timestamp()
+  };
+}
+function pickPublicStreamFields(event) {
+  if (event.type === "session_created" || event.type === "session_resumed") return {};
+  if (event.type === "backend_start" || event.type === "backend_end") return { backend: event.backend };
+  if (event.type === "backend_error") return { backend: event.backend, message: event.message, recoverable: event.recoverable };
+  if (event.type === "task_end") return { status: event.status, reason: event.reason };
+  if (event.type === "text_delta" || event.type === "reasoning_delta") return { text: event.text };
+  return {};
+}
+function mapCommonBackendEvent(event, context) {
+  if (!event || typeof event !== "object") return void 0;
+  const record = event;
+  const type = String(record.type ?? "");
+  const data = record.data && typeof record.data === "object" ? record.data : record;
+  if (type === "message.part.updated" || type === "text_delta" || type === "delta") {
+    const text = stringValue(data.text) ?? stringValue(data.delta) ?? stringValue(record.text);
+    return text ? { type: "text_delta", task: context.task, session: context.session, text, timestamp: timestamp() } : void 0;
+  }
+  if (type === "reasoning_delta") {
+    const text = stringValue(data.text) ?? stringValue(record.text);
+    return text ? { type: "reasoning_delta", task: context.task, session: context.session, text, timestamp: timestamp() } : void 0;
+  }
+  if (type === "tool_call") {
+    return {
+      type: "tool_call",
+      task: context.task,
+      session: context.session,
+      toolName: stringValue(data.name) ?? stringValue(record.toolName) ?? "tool",
+      toolCallId: stringValue(data.id) ?? stringValue(record.toolCallId),
+      args: data.args ?? data.input ?? record.args,
+      timestamp: timestamp()
+    };
+  }
+  if (type === "tool_result") {
+    return {
+      type: "tool_result",
+      task: context.task,
+      session: context.session,
+      toolName: stringValue(data.name) ?? stringValue(record.toolName) ?? "tool",
+      toolCallId: stringValue(data.id) ?? stringValue(record.toolCallId),
+      result: data.result ?? data.output ?? record.result,
+      timestamp: timestamp()
+    };
+  }
+  if (type === "result" || type === "final") {
+    const text = stringValue(data.finalText) ?? stringValue(data.text) ?? stringValue(record.text);
+    return text ? { type: "text_delta", task: context.task, session: context.session, text, timestamp: timestamp() } : void 0;
+  }
+  return void 0;
+}
+async function* streamResponseEvents(response, context) {
+  const body = response.body;
+  if (!body) return;
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const chunks = buffer.split(/\n\n/);
+    buffer = chunks.pop() ?? "";
+    for (const chunk of chunks) {
+      const event = parseStreamChunk(chunk, context);
+      if (event) yield event;
+    }
+  }
+  if (buffer.trim()) {
+    const event = parseStreamChunk(buffer, context);
+    if (event) yield event;
+  }
+}
+function parseStreamChunk(chunk, context) {
+  const data = chunk.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+  if (!data || data === "[DONE]") return void 0;
+  try {
+    const parsed = JSON.parse(data);
+    const choice = Array.isArray(parsed.choices) ? parsed.choices[0] : void 0;
+    const delta = choice?.delta;
+    const message = choice?.message;
+    const text = stringValue(delta?.content) ?? stringValue(message?.content) ?? stringValue(parsed.text);
+    if (text) return { type: "text_delta", task: context.task, session: context.session, text, timestamp: timestamp() };
+    return mapCommonBackendEvent(parsed, context);
+  } catch {
+    return { type: "text_delta", task: context.task, session: context.session, text: data, timestamp: timestamp() };
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 function buildReadiness(task, provider) {
   if (provider?.buildReadiness) return provider.buildReadiness(task);
   return scoreKnowledgeReadiness({
@@ -373,13 +815,21 @@ function toAgentContext(task, knowledge, ctx) {
   };
 }
 export {
+  InMemoryRuntimeSessionStore,
+  createCliBridgeBackend,
+  createIterableBackend,
+  createOpenAICompatibleBackend,
   createRuntimeEventCollector,
+  createSandboxPromptBackend,
   decideKnowledgeReadiness,
   encodeServerSentEvent,
   readinessServerSentEvent,
   runAgentTask,
+  runAgentTaskStream,
+  runtimeStreamServerSentEvent,
   sanitizeAgentRuntimeEvent,
   sanitizeKnowledgeReadinessReport,
+  sanitizeRuntimeStreamEvent,
   summarizeAgentTaskRun
 };
 //# sourceMappingURL=index.js.map