@inflexa-ai/harness 0.35.7 → 0.35.8

package/dist/loop/genai-spans.d.ts

@@ -0,0 +1,20 @@
+/**
+ * OpenTelemetry GenAI spans for the agent loop: `invoke_agent` around a run of
+ * `runAgent`, and `execute_tool` around each tool call that it dispatches. The AI
+ * SDK traces the model calls (`providers/ai-sdk.ts`). It never sees the loop or
+ * the tools, because the harness runs both itself.
+ */
+import type { ToolCallPart } from "ai";
+import type { AgentSession } from "../auth/types.js";
+import type { ToolOutcome } from "./tool-outcome.js";
+interface AgentRun {
+    readonly finish: {
+        readonly reason: string;
+        readonly cappedOut: boolean;
+    };
+}
+/** Run one agent loop under an `invoke_agent` span. */
+export declare function traceAgentRun<T extends AgentRun>(agentName: string, session: AgentSession, run: () => Promise<T>): Promise<T>;
+/** Run one tool call under an `execute_tool` span that records how the call ended. */
+export declare function traceToolCall<T>(call: Pick<ToolCallPart, "toolName" | "toolCallId">, run: () => Promise<T>, outcomeOf: (value: T) => ToolOutcome): Promise<T>;
+export {};

package/dist/loop/genai-spans.js

@@ -0,0 +1,53 @@
+/**
+ * OpenTelemetry GenAI spans for the agent loop: `invoke_agent` around a run of
+ * `runAgent`, and `execute_tool` around each tool call that it dispatches. The AI
+ * SDK traces the model calls (`providers/ai-sdk.ts`). It never sees the loop or
+ * the tools, because the harness runs both itself.
+ */
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+/** Run one agent loop under an `invoke_agent` span. */
+export function traceAgentRun(agentName, session, run) {
+    const attributes = { "gen_ai.operation.name": "invoke_agent", "gen_ai.agent.name": agentName, ...runFrameAttributes(session) };
+    return withSpan(`invoke_agent ${agentName}`, attributes, async (span) => {
+        const result = await run();
+        span.setAttributes({ "gen_ai.response.finish_reasons": [result.finish.reason], "inflexa.agent.capped_out": result.finish.cappedOut });
+        return result;
+    });
+}
+/** Run one tool call under an `execute_tool` span that records how the call ended. */
+export function traceToolCall(call, run, outcomeOf) {
+    const attributes = { "gen_ai.operation.name": "execute_tool", "gen_ai.tool.name": call.toolName, "gen_ai.tool.call.id": call.toolCallId };
+    return withSpan(`execute_tool ${call.toolName}`, attributes, async (span) => {
+        const value = await run();
+        const outcome = outcomeOf(value);
+        span.setAttribute("inflexa.tool.outcome", outcome);
+        if (outcome === "error")
+            span.setStatus({ code: SpanStatusCode.ERROR });
+        return value;
+    });
+}
+function withSpan(name, attributes, run) {
+    return trace.getTracer("@inflexa-ai/harness").startActiveSpan(name, { attributes }, async (span) => {
+        try {
+            return await run(span);
+        }
+        catch (err) {
+            // A cancellation is the caller's decision, not a failure.
+            const cancelled = err instanceof Error && err.name === "AbortError";
+            if (!cancelled) {
+                span.setStatus({ code: SpanStatusCode.ERROR });
+                if (err instanceof Error)
+                    span.recordException(err);
+            }
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+function runFrameAttributes({ runFrame }) {
+    if (runFrame === undefined)
+        return {};
+    return { "inflexa.run_id": runFrame.runId, ...(runFrame.stepId === undefined ? {} : { "inflexa.step_id": runFrame.stepId }) };
+}

package/dist/loop/run-agent.js

@@ -13,6 +13,7 @@ import { DEFAULT_REASONING } from "../providers/reasoning.js";
 import { resultStep } from "./run-step.js";
 import { AskRejectedError, UnavailableAsk } from "../tools/approval/contract.js";
 import { isToolError, readToolResultImages } from "../tools/define-tool.js";
+import { traceAgentRun, traceToolCall } from "./genai-spans.js";
 import { addChatUsage, hasReportedUsage, recordAgentRun } from "./metrics.js";
 import { computeDetail, computeResultDetail } from "./tool-detail.js";
 import { toolOutcomeForOutputType } from "./tool-outcome.js";
@@ -22,7 +23,10 @@ export const DEFAULT_STEP_NAME_FORMATTER = {
     llm: (i) => `llm-${i}`,
     tool: (name, id) => `tool-${name}-${id}`,
 };
-export async function runAgent(agent, initial, session, opts) {
+export function runAgent(agent, initial, session, opts) {
+    return traceAgentRun(agent.id, session, () => runAgentLoop(agent, initial, session, opts));
+}
+async function runAgentLoop(agent, initial, session, opts) {
     const { provider, signal, emit, runStep } = opts;
     const formatStepName = opts.formatStepName ?? DEFAULT_STEP_NAME_FORMATTER;
     const configuredFatalLoopError = opts.isFatalLoopError ?? (() => false);
@@ -524,6 +528,7 @@ function appendDeferredImages(messages, results, deferredImages) {
  * is genuinely fast. A bracket inside the step would report a body that did not run.
  */
 async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, runStep, toolStepName, encoding) {
+    const dispatch = (tu) => traceToolCall(tu, () => dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding), (dispatched) => outcomeOf(dispatched.result));
     const results = new Array(toolUses.length);
     // The array starts with holes, which read as `undefined`. The element type
     // says so, thus it agrees with what `settleRound` accepts. Every index is in
@@ -550,7 +555,7 @@ async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, run
         const stepName = toolStepName(tu.toolName, tu.toolCallId);
         return runStep(stepName, () => {
             stableSpan(stepName, `tool:${tu.toolName}`, { [ATTR_INFLEXA_TOOL_USE_ID]: tu.toolCallId });
-            return dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding);
+            return dispatch(tu);
         }).then((settled) => {
             durations[idx] = elapsedMs(startedAt);
             const dispatched = readDispatchedStep(settled);
@@ -561,7 +566,7 @@ async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, run
     }));
     for (const { tu, idx } of workflowTools) {
         const startedAt = performance.now();
-        const dispatched = await dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding);
+        const dispatched = await dispatch(tu);
         results[idx] = dispatched.result;
         if (dispatched.detail !== undefined)
             resultDetails[idx] = dispatched.detail;
@@ -569,7 +574,7 @@ async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, run
     }
     for (const { tu, idx } of inlineTools) {
         const startedAt = performance.now();
-        const dispatched = await dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding);
+        const dispatched = await dispatch(tu);
         results[idx] = dispatched.result;
         if (dispatched.detail !== undefined)
             resultDetails[idx] = dispatched.detail;

package/dist/providers/ai-sdk.js

@@ -2,6 +2,7 @@ import { streamText, wrapLanguageModel, } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { OpenTelemetry } from "@ai-sdk/otel";
 import { APICallError } from "@ai-sdk/provider";
 import { retryWithExponentialBackoff } from "@ai-sdk/provider-utils";
 import { ResultAsync, err, ok } from "neverthrow";
@@ -431,6 +432,11 @@ export function createAiSdkProvider(deps) {
     const maxRetries = deps.maxRetries ?? RETRY_MAX_RETRIES;
     const requestTimeoutMs = deps.requestTimeoutMs;
     const requestedModelId = requestedModelIdOf(deps.model);
+    // Each model call emits OpenTelemetry GenAI spans through the AI SDK, with no
+    // prompt or completion text on them. The integration rides on each call
+    // instead of the global registry, so the harness never traces the embedder's
+    // own AI SDK calls.
+    const telemetry = { integrations: new OpenTelemetry(), recordInputs: false, recordOutputs: false };
     routeSdkWarningsTo(logger);
     /**
      * Record a call that the envelope gave up on.
@@ -484,6 +490,7 @@ export function createAiSdkProvider(deps) {
                         maxRetries: 0,
                         headers,
                         abortSignal: signal,
+                        telemetry,
                         // `firstChunkMs` bounds the wait for the first content chunk,
                         // and `chunkMs` bounds each later gap. Thus each silent interval
                         // carries the one configured bound, and a turn that writes
@@ -560,6 +567,7 @@ export function createAiSdkProvider(deps) {
                     maxRetries: 0,
                     headers,
                     abortSignal: signal,
+                    telemetry,
                     // The fetch guard bounds the wait until the headers. Past the
                     // headers the SDK owns two bounds: `firstChunkMs` covers the wait
                     // for the first content chunk, and `chunkMs` covers each later

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.35.7",
+    "version": "0.35.8",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
@@ -47,11 +47,12 @@
         "typecheck": "tsc --noEmit"
     },
     "dependencies": {
-        "@ai-sdk/anthropic": "^4.0.38",
-        "@ai-sdk/openai": "^4.0.39",
-        "@ai-sdk/openai-compatible": "^3.0.30",
-        "@ai-sdk/provider": "^4.0.7",
-        "@ai-sdk/provider-utils": "5.0.27",
+        "@ai-sdk/anthropic": "^4.0.53",
+        "@ai-sdk/openai": "^4.0.66",
+        "@ai-sdk/openai-compatible": "^3.0.48",
+        "@ai-sdk/otel": "^1.0.99",
+        "@ai-sdk/provider": "^4.0.14",
+        "@ai-sdk/provider-utils": "5.0.40",
         "@anthropic-ai/sdk": "^0.116.0",
         "@dbos-inc/dbos-sdk": "^4.23.6",
         "@fontsource-variable/space-grotesk": "5.1.1",
@@ -68,7 +69,7 @@
         "@opentelemetry/sdk-trace-node": "^2.9.0",
         "@opentelemetry/semantic-conventions": "^1.43.0",
         "ag-grid-community": "36.1.0",
-        "ai": "^7.0.61",
+        "ai": "^7.0.99",
         "cheerio": "^1.2.0",
         "dockerode": "^4.0.12",
         "echarts": "6.1.0",
@@ -94,7 +95,7 @@
         "uuid": "^11.1.1"
     },
     "devDependencies": {
-        "@ai-sdk/amazon-bedrock": "^5.0.74",
+        "@ai-sdk/amazon-bedrock": "^5.0.82",
         "@eslint/js": "^10.0.1",
         "@types/bun": "latest",
         "@types/dockerode": "^3.3.47",