eve 0.47.2 → 0.47.5

package/docs/guides/dynamic-capabilities.md

@@ -1,9 +1,9 @@
 ---
 title: "Dynamic Capabilities"
-description: "Resolve models, subagents, tools, skills, and instructions at runtime with defineDynamic resolver events."
+description: "Resolve models, subagents, connections, tools, skills, and instructions at runtime with defineDynamic resolver events."
 ---
 
-`defineDynamic` resolves the model, subagents, tools, skills, and instructions at runtime from a session event instead of declaring them up front. Reach for it when the right capability isn't known until the session starts, because it hinges on who the caller is, what tenant they belong to, feature flags, or external data. The [subagents](../subagents), [tools](../tools), [skills](../skills), and [instructions](../instructions) guides each point here for their dynamic form.
+`defineDynamic` resolves the model, subagents, connections, tools, skills, and instructions at runtime from a session event instead of declaring them up front. Reach for it when the right capability isn't known until the session starts, because it hinges on who the caller is, what tenant they belong to, feature flags, or external data. The [subagents](../subagents), [connections](../connections), [tools](../tools), [skills](../skills), and [instructions](../instructions) guides each point here for their dynamic form.
 
 eve evaluates a dynamic definition module once during compilation to classify and validate it, then retains that module as a runtime entry so its event handlers can run. Its top-level code therefore runs in both phases; keep caller-specific work inside the handlers. See [Authored module lifecycle](../reference/typescript-api#authored-module-lifecycle).
 
@@ -20,8 +20,8 @@ full contract.
 
 Dynamic models do not compile a default model or model metadata. When a
 resolver first selects a model, eve normalizes the selection and resolves any
-omitted context-window metadata from the AI Gateway catalog. Dynamic tools,
-skills, instructions, and subagents may return `null` to omit a capability.
+omitted context-window metadata from the AI Gateway catalog. Dynamic connections,
+tools, skills, instructions, and subagents may return `null` to omit a capability.
 
 ### Route image inputs to a vision model
 
@@ -132,6 +132,91 @@ availability as capability composition, not as the only authorization
 boundary: sensitive child tools still need their own authorization and
 approval checks.
 
+## Dynamic connections
+
+Use a dynamic connection when the available MCP servers or OpenAPI services
+depend on the authenticated caller. A handler returns one
+`defineMcpClientConnection(...)` or `defineOpenAPIConnection(...)`, a map of
+connection definitions, or `null`. Wrap every returned connection in its
+protocol helper. Connection resolvers receive `ctx.session` and
+`ctx.channel.kind`; they do not receive conversation messages, delivery
+payloads, tool inputs, model outputs, continuation tokens, or free-form channel
+metadata. Select accounts and endpoints from authenticated session identity or
+application-owned data.
+
+This example exposes one MCP connection for each cloud account enabled for the
+current user:
+
+```ts title="agent/connections/accounts.ts"
+import { defineDynamic, defineMcpClientConnection } from "eve/connections";
+import { listEnabledAccounts, mintAccountToken } from "../lib/accounts";
+
+export default defineDynamic({
+  events: {
+    "session.started": async (_event, ctx) => {
+      const principal = ctx.session.auth.current;
+      if (principal?.principalType !== "user") return null;
+
+      const accounts = await listEnabledAccounts(principal);
+      return Object.fromEntries(
+        accounts.map((account) => [
+          account.slug,
+          defineMcpClientConnection({
+            url: "https://mcp.cloud.example.com",
+            description: `${account.label} (${account.accountId})`,
+            instanceKey: account.accountId,
+            auth: {
+              principalType: "user",
+              getToken: ({ principal }) => mintAccountToken(principal, account),
+            },
+          }),
+        ]),
+      );
+    },
+  },
+});
+```
+
+The returned definitions use the same auth, headers, filtering, provided
+arguments, and approval options as static [MCP](../connections/mcp) and
+[OpenAPI](../connections/openapi) connections. Each resolved connection joins
+the per-step connection registry, appears in `connection_search`, and exposes
+discovered tools as `<connection>__<tool>`.
+
+Set `instanceKey` on every authenticated dynamic connection. Use a stable,
+non-secret account or tenant identifier, and change it whenever the endpoint,
+account, or auth provider changes. eve hashes the value before storing the
+resolved instance identity in durable authorization state. If a parked sign-in
+callback resumes after the resolver selects a different instance, eve rejects
+the callback instead of passing it to the new connection or reusing its token.
+
+### Naming and conflicts
+
+| Return shape                  | File                            | Connection name(s)      |
+| ----------------------------- | ------------------------------- | ----------------------- |
+| single connection definition  | `agent/connections/accounts.ts` | `accounts`              |
+| map `{ production, staging }` | `agent/connections/accounts.ts` | `production`, `staging` |
+
+A map key must be a legal connection name: lowercase ASCII letters, digits,
+and dashes, starting with a letter, up to 64 characters. Map keys are bare;
+eve does not prefix them with the file slug. A dynamic connection overrides a
+same-named static connection. Two effective dynamic resolvers cannot emit the
+same name; namespace one map key to remove the ambiguity.
+
+### Events and recovery
+
+Dynamic connections support `session.started` and `turn.started`. A turn result
+replaces that file's session result for the turn, including when the turn
+handler returns `null`. A throwing or invalid handler fails the lifecycle
+without rebuilding the registry, so a static connection shadowed by the
+dynamic result cannot reappear as a fallback.
+
+eve may run the active session and turn handlers again when a parked turn
+resumes or a durable step retries. This rebuilds live auth, header, approval,
+and provided-argument callbacks without serializing them into workflow state.
+Keep connection resolvers idempotent, and keep external side effects outside
+the handler.
+
 ## Dynamic tools
 
 Pass `defineDynamic` an `events` object whose handlers return either a single `defineTool(...)`, a `Record<string, defineTool(...)>`, or `null` for no tools. Wrap every entry in `defineTool()`. eve records durable descriptors for `execute`, approval request and response policies, and `toModelOutput`, so a parked call can reconstruct the same callbacks in a fresh process.
@@ -189,7 +274,7 @@ A single return produces one tool named after the file slug, identical to a stat
 
 ### Conflicts
 
-A dynamic tool or skill whose name matches an **authored** one **overrides** it — a per-caller resolver can replace a built-in by name. Two **dynamic** resolvers emitting the same name is a genuine ambiguity and throws; namespace one of the keys manually to resolve it.
+A dynamic connection, tool, or skill whose name matches an **authored** one **overrides** it — a per-caller resolver can replace a static capability by name. Two **dynamic** resolvers of the same capability type emitting the same name is a genuine ambiguity and throws; namespace one of the keys manually to resolve it.
 
 ### Events
 
@@ -310,6 +395,7 @@ Dynamic system content that changes frequently can reduce provider prompt-cache
 ## What to read next
 
 - Conditionally expose a specialist → [Subagents](../subagents)
+- Resolve caller-specific external services → [Connections](../connections)
 - The static tool basics this builds on → [Tools](../tools)
 - The built-in tools and how to override them → [Built-in tools](../concepts/built-in-tools)
 - Authenticate a tool or connection to an external service → [Auth & route protection](./auth-and-route-protection)

package/docs/memory.md

@@ -29,12 +29,15 @@ recall and maintain memory:
 | Provider        | Status         | Use it for                                                                |
 | --------------- | -------------- | ------------------------------------------------------------------------- |
 | `fileMemory()`  | Built into eve | A bounded, model-maintained list of durable facts and preferences         |
-| Supermemory     | Coming soon    | The first third-party implementation of the eve provider contract         |
+| Supermemory     | Third-party    | Semantic recall, automatic capture, source extraction, and memory tools   |
 | Custom provider | Supported      | Application-specific retrieval, capture, retention, or model-facing tools |
 
-Supermemory is building the first third-party provider for eve. It is not
-available yet; until it is released, use `fileMemory()` or implement the
-provider contract described below.
+[Supermemory](https://github.com/supermemoryai/eve-supermemory#readme) is a
+third-party provider that recalls relevant context before each turn, captures
+completed turns, and supplies search, memory-management, and source-extraction
+tools. Add it with `eve add memory/supermemory`. It requires a Supermemory API
+key and a memory scope you choose; review its retention and data handling before
+sending sensitive content to the service.
 
 ## Use file memory
 

package/docs/reference/cli.md

@@ -52,11 +52,11 @@ Coding-agent launches and non-interactive terminals cannot answer the location p
 
 After scaffolding, a human terminal usually continues into `eve dev`. If a coding-agent REPL is on `PATH`, the handoff menu can open it instead or exit without starting either process. Coding-agent launches print the next steps instead of opening the TUI, so the session does not get stuck. Fresh projects use the parent workspace's package manager when there is one; otherwise they use the manager that launched `eve init`.
 
-| Flag                   | Type   | Default          | Description                                                                                                              |
-| ---------------------- | ------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| Flag                   | Type   | Default                    | Description                                                                                                              |
+| ---------------------- | ------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
 | `--model <model>`      | string | `openai/gpt-5.6-luna-fast` | Set the root agent's AI Gateway model ID.                                                                                |
-| `--reasoning <effort>` | enum   | provider default | Set reasoning to `none`, `minimal`, `low`, `medium`, `high`, or `xhigh`. `provider-default` leaves the field unauthored. |
-| `--channel-web-nextjs` | flag   | off              | Add the Web Chat app (Next.js). Not for existing projects — run `eve add channel/web` there instead.                     |
+| `--reasoning <effort>` | enum   | provider default           | Set reasoning to `none`, `minimal`, `low`, `medium`, `high`, or `xhigh`. `provider-default` leaves the field unauthored. |
+| `--channel-web-nextjs` | flag   | off                        | Add the Web Chat app (Next.js). Not for existing projects — run `eve add channel/web` there instead.                     |
 
 ## `eve extension`
 
@@ -294,15 +294,15 @@ eve traces --json          # dump the full trace as JSON
 
 Reads the immutable OTLP/JSON segments under `.eve/traces/v1`, so `eve dev` need not be running. Accepts a full trace id, an `agent.session.id`, or an unambiguous prefix of either. Malformed segments are skipped without hiding valid spans from the same trace.
 
-Span rows carry inline metrics when the span recorded them — `↑input`/`↓output` token counts, gateway cost, and the tool name for `ai.toolCall` spans — and the header aggregates models, token totals, cost, and error count across the trace's step spans. `--verbose` expands each span under its tree row: status (with the error message on failures), timing, ids, every attribute (prompts, responses, and tool payloads as transcripts or pretty-printed JSON), and every span event with its offset from span start. `--json` prints the same records as JSON, one object per selected trace.
+Span rows carry inline metrics when the span recorded them — `↑input`/`↓output` token counts, gateway cost, and the tool name for `execute_tool` spans — and the header aggregates models, token totals, cost, and error count across the trace's step spans. `--verbose` expands each span under its tree row: status (with the error message on failures), timing, ids, every attribute (prompts, responses, and tool payloads as transcripts or pretty-printed JSON), and every span event with its offset from span start. `--json` prints the same records as JSON, one object per selected trace.
 
-A local subagent keeps its own session id but records into the parent trace. Its turn is parented to the `agent.action` span that dispatched it, so the span tree carries the relationship without duplicate lineage attributes; `agent.subagent.name` remains on the child turn as a standalone label. Either session id resolves to that trace. Remote agents propagate the parent trace context over `traceparent`.
+A local subagent keeps its own session id but records into the parent trace. Its `invoke_agent` span is parented to the `agent.action` span that dispatched it, so the span tree carries the relationship without duplicate lineage attributes; `agent.subagent.name` remains on the child invocation as a standalone label. Either session id resolves to that trace. Remote agents propagate the parent trace context over `traceparent`.
 
 A durable session keeps one persisted trace context across turns and worker resumptions. Independently replayed attempts can still produce another trace; passing the session id shows every trace it produced, oldest first.
 
-Every span carries a real duration except `agent.session`: an idle session never closes, so it is recorded as a zero-duration marker and the span tree shows its descendant extent instead. A turn's span is written when the turn settles, so a running turn shows only its steps.
+Every span carries a real duration except `agent.session`: an idle session never closes, so it is recorded as a zero-duration marker and the span tree shows its descendant extent instead. A turn's `invoke_agent` span is written when the turn settles, so a running turn shows only its steps.
 
-Model and tool-call spans omit their inputs and outputs by default. Set `EVE_TRACES_CONTENT=on` to capture system prompts, prompt messages, and response text for models, plus call arguments and results for tools. Each captured value is capped at 32 KB.
+Model and `execute_tool` spans omit their inputs and outputs by default. Set `EVE_TRACES_CONTENT=on` to capture system prompts, prompt messages, and response text for models, plus call arguments and results for tools. Each captured value is capped at 32 KB.
 
 Step spans carry token counts, and cost when Vercel AI Gateway served the call. Both follow the [OTel GenAI semantic conventions](https://github.com/open-telemetry/semantic-conventions-genai) (`gen_ai.usage.*`), so a third-party backend reads them without mapping.
 

package/docs/reference/typescript-api.md

@@ -30,28 +30,28 @@ export default defineTool({
 
 ## The define\* helpers
 
-| Helper                                                | Import from                                          | Authored at                                                                | Guide                                                  |
-| ----------------------------------------------------- | ---------------------------------------------------- | -------------------------------------------------------------------------- | ------------------------------------------------------ |
-| `defineAgent`                                         | `eve`                                                | `agent/agent.ts`                                                           | [agent.ts](../agent-config)                            |
-| `defineTool`                                          | `eve/tools`                                          | `agent/tools/<name>.ts`                                                    | [Tools](../tools)                                      |
-| `defineDynamic`                                       | `eve`, `eve/tools`, `eve/skills`, `eve/instructions` | dynamic model or subagent `agent.ts`; `agent/{tools,skills,instructions}/` | [Dynamic capabilities](../guides/dynamic-capabilities) |
-| `defineMcpClientConnection`                           | `eve/connections`                                    | `agent/connections/<name>.ts`                                              | [MCP connections](../connections/mcp)                  |
-| `defineOpenAPIConnection`                             | `eve/connections`                                    | `agent/connections/<name>.ts`                                              | [OpenAPI connections](../connections/openapi)          |
-| `defineChannel`                                       | `eve/channels`                                       | `agent/channels/<name>.ts`                                                 | [Custom channels](../channels/custom)                  |
-| `eveChannel`, `slackChannel`, and the other platforms | `eve/channels/<platform>`                            | `agent/channels/<platform>.ts`                                             | [Channels](../channels/overview)                       |
-| `defineSkill`                                         | `eve/skills`                                         | `agent/skills/<name>.ts`                                                   | [Skills](../skills)                                    |
-| `defineInstructions`                                  | `eve/instructions`                                   | `agent/instructions.ts`                                                    | [Instructions](../instructions)                        |
-| `defineMemory`, `defineMemoryProvider`                | `eve/memory`                                         | `agent/memory.ts` or `agent/memory/<slot>.ts`                              | [Memory](../memory)                                    |
-| `defineHook`                                          | `eve/hooks`                                          | `agent/hooks/<slug>.ts`                                                    | [Hooks](../guides/hooks)                               |
-| `defineSchedule`                                      | `eve/schedules`                                      | `agent/schedules/<name>.ts`                                                | [Schedules](../schedules)                              |
-| `defineState`                                         | `eve/context`                                        | tools, hooks, lifecycle                                                    | [Session context](../guides/session-context)           |
-| `defineSandbox`                                       | `eve/sandbox`                                        | `agent/sandbox.ts`                                                         | [Sandbox](../sandbox)                                  |
-| `defineInstrumentation`                               | `eve/instrumentation`                                | `agent/instrumentation.ts`                                                 | [instrumentation.ts](../guides/instrumentation)        |
-| `defineRemoteAgent`                                   | `eve`                                                | `agent/subagents/<id>/agent.ts`                                            | [Remote agents](../guides/remote-agents)               |
-| `defineEval`                                          | `eve/evals`                                          | `evals/*.eval.ts`                                                          | [Evals](../evals/overview)                             |
-| `defineEvalConfig`                                    | `eve/evals`                                          | `evals/evals.config.ts`                                                    | [Evals](../evals/overview)                             |
-| `mockModel`                                           | `eve/evals`                                          | Deterministic fixture agent models                                         | [Evals](../evals/overview)                             |
-| `useEveAgent`                                         | `eve/react`, `eve/vue`, `eve/svelte`                 | frontend                                                                   | [Frontend](../guides/frontend/overview)                |
+| Helper                                                | Import from                                                             | Authored at                                                                            | Guide                                                  |
+| ----------------------------------------------------- | ----------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ------------------------------------------------------ |
+| `defineAgent`                                         | `eve`                                                                   | `agent/agent.ts`                                                                       | [agent.ts](../agent-config)                            |
+| `defineTool`                                          | `eve/tools`                                                             | `agent/tools/<name>.ts`                                                                | [Tools](../tools)                                      |
+| `defineDynamic`                                       | `eve`, `eve/tools`, `eve/skills`, `eve/instructions`, `eve/connections` | dynamic model or subagent `agent.ts`; `agent/{tools,skills,instructions,connections}/` | [Dynamic capabilities](../guides/dynamic-capabilities) |
+| `defineMcpClientConnection`                           | `eve/connections`                                                       | `agent/connections/<name>.ts`                                                          | [MCP connections](../connections/mcp)                  |
+| `defineOpenAPIConnection`                             | `eve/connections`                                                       | `agent/connections/<name>.ts`                                                          | [OpenAPI connections](../connections/openapi)          |
+| `defineChannel`                                       | `eve/channels`                                                          | `agent/channels/<name>.ts`                                                             | [Custom channels](../channels/custom)                  |
+| `eveChannel`, `slackChannel`, and the other platforms | `eve/channels/<platform>`                                               | `agent/channels/<platform>.ts`                                                         | [Channels](../channels/overview)                       |
+| `defineSkill`                                         | `eve/skills`                                                            | `agent/skills/<name>.ts`                                                               | [Skills](../skills)                                    |
+| `defineInstructions`                                  | `eve/instructions`                                                      | `agent/instructions.ts`                                                                | [Instructions](../instructions)                        |
+| `defineMemory`, `defineMemoryProvider`                | `eve/memory`                                                            | `agent/memory.ts` or `agent/memory/<slot>.ts`                                          | [Memory](../memory)                                    |
+| `defineHook`                                          | `eve/hooks`                                                             | `agent/hooks/<slug>.ts`                                                                | [Hooks](../guides/hooks)                               |
+| `defineSchedule`                                      | `eve/schedules`                                                         | `agent/schedules/<name>.ts`                                                            | [Schedules](../schedules)                              |
+| `defineState`                                         | `eve/context`                                                           | tools, hooks, lifecycle                                                                | [Session context](../guides/session-context)           |
+| `defineSandbox`                                       | `eve/sandbox`                                                           | `agent/sandbox.ts`                                                                     | [Sandbox](../sandbox)                                  |
+| `defineInstrumentation`                               | `eve/instrumentation`                                                   | `agent/instrumentation.ts`                                                             | [instrumentation.ts](../guides/instrumentation)        |
+| `defineRemoteAgent`                                   | `eve`                                                                   | `agent/subagents/<id>/agent.ts`                                                        | [Remote agents](../guides/remote-agents)               |
+| `defineEval`                                          | `eve/evals`                                                             | `evals/*.eval.ts`                                                                      | [Evals](../evals/overview)                             |
+| `defineEvalConfig`                                    | `eve/evals`                                                             | `evals/evals.config.ts`                                                                | [Evals](../evals/overview)                             |
+| `mockModel`                                           | `eve/evals`                                                             | Deterministic fixture agent models                                                     | [Evals](../evals/overview)                             |
+| `useEveAgent`                                         | `eve/react`, `eve/vue`, `eve/svelte`                                    | frontend                                                                               | [Frontend](../guides/frontend/overview)                |
 
 Tool-wide authoring helpers such as `defineTool`, `defineDynamic`, and `disableTool` come from `eve/tools`. Capability-specific definitions and helpers use their own subpaths (see [Built-in tools](../concepts/built-in-tools)): reusable definitions such as `bash` and `glob` come from `eve/tools/<name>`, `webSearch` comes from `eve/tools/web_search`, `experimental_workflow` comes from `eve/tools/workflow`, `sleep` comes from `eve/tools/sleep`, and approval policies and types come from `eve/tools/approval`. The route verbs `GET`/`HEAD`/`POST`/`PUT`/`PATCH`/`DELETE`/`OPTIONS`/`WS` plus `disableRoute` come from `eve/channels`, and the channel auth helpers `localDev`/`vercelOidc`/`placeholderAuth` come from `eve/channels/auth`.
 
@@ -59,6 +59,15 @@ Tool-wide authoring helpers such as `defineTool`, `defineDynamic`, and `disableT
 
 `defineInstructions` accepts `{ content: string, role?: "system" | "user" }`; omitted `role` means `"system"`. Its `eve/instructions` version of `defineDynamic` accepts only `session.started` and `turn.started` handlers returning `defineInstructions(...)` or `null`. The legacy `{ markdown: string }` definition remains available as a deprecated system-role form.
 
+The `eve/connections` version of `defineDynamic` accepts `session.started` and
+`turn.started` handlers returning one MCP or OpenAPI connection definition, a
+map of connection definitions, or `null`. Its resolver context exposes
+authenticated session identity and `channel.kind`, but not conversation history,
+delivery payloads, tool inputs, model outputs, or free-form channel metadata. An
+authenticated returned definition must set `instanceKey` to a stable,
+non-secret account or tenant identifier so durable authorization resumes cannot
+cross resolved instances.
+
 ## Authored module lifecycle
 
 eve evaluates TypeScript definition modules during compilation so it can validate and normalize the agent. Within one agent node, each module namespace loads at most once during that compile. The resolved definition then determines whether the module is also an entry in the runtime bundle:
@@ -107,7 +116,7 @@ import template from "../../prompts/template.txt?raw";
 | `eve/tools/web_search`                                                      | Provider-managed `webSearch` configuration                                |
 | `eve/tools/workflow`                                                        | Experimental `Workflow` tool definition                                   |
 | `eve/tools/sleep`                                                           | Opt-in durable `sleep` tool                                               |
-| `eve/connections`                                                           | `defineMcpClientConnection`, `defineOpenAPIConnection`                    |
+| `eve/connections`                                                           | `defineMcpClientConnection`, `defineOpenAPIConnection`, `defineDynamic`   |
 | `eve/channels`                                                              | `defineChannel`, `disableRoute`, route verbs                              |
 | `eve/channels/eve`                                                          | `eveChannel`                                                              |
 | `eve/channels/auth`                                                         | `localDev`, `vercelOidc`, `placeholderAuth`                               |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.47.2",
+  "version": "0.47.5",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [

package/dist/src/execution/subagent-usage-span.d.ts

@@ -1,9 +0,0 @@
-import type { RuntimeActionResult } from "#shared/action-types.js";
-/**
- * Emits one caller-side `invoke_agent` span per successful delegated
- * subagent result that reports token usage, so the parent session's
- * observability can attribute a child agent's tokens. Runs in the
- * parent's turn step, so the span lands in the caller's trace.
- * Best-effort: a tracer failure never blocks the turn.
- */
-export declare function recordSubagentUsageSpans(results: readonly RuntimeActionResult[]): void;

package/dist/src/execution/subagent-usage-span.js

@@ -1 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{trace}from"#compiled/@opentelemetry/api/index.js";const log=createLogger(`execution.subagent-usage-span`);function recordSubagentUsageSpans(e){for(let t of e){if(t.kind!==`subagent-result`||t.isError===!0)continue;let e=t.usage;if(e!==void 0)try{trace.getTracer(`eve`).startSpan(`invoke_agent ${t.subagentName}`,{attributes:{"gen_ai.operation.name":`invoke_agent`,"gen_ai.agent.name":t.subagentName,"gen_ai.usage.input_tokens":e.inputTokens,"gen_ai.usage.output_tokens":e.outputTokens,"gen_ai.usage.cache_read.input_tokens":e.cacheReadTokens,"gen_ai.usage.cache_creation.input_tokens":e.cacheWriteTokens}}).end()}catch(e){log.warn(`failed to emit subagent usage span`,{error:e})}}}export{recordSubagentUsageSpans};

package/dist/src/harness/ai-sdk-hook-bridge.js

@@ -1 +0,0 @@
-import{attemptIdempotencyKey,modelCallIdempotencyKey,toolCallIdempotencyKey}from"#harness/instrumentation/lifecycle.js";import{structuralProviderMetadata}from"#harness/instrumentation/content.js";function createAiSdkHookBridge(i,a,o=directRunInContext,s){let c={capturesContent:a.capturesContent,modelKeys:new Map,runtimeContext:s!==void 0&&Object.keys(s).length>0?Object.freeze({...s}):void 0,scope:i,toolKeys:new Map};return{onStart(e){c.operation=Object.freeze({modelId:e.modelId,operationId:e.operationId,provider:e.provider})},async onStepStart(e){c.stepNumber=e.stepNumber;let t=toStepAttemptStarted(c);t!==void 0&&await a.publish(t)},async onLanguageModelCallStart(e){let n=modelCallIdempotencyKey(c.scope,c.stepNumber??0);c.modelKeys.set(e.callId,n);let r=toModelCallStarted(c,n,e);await a.publish(r)},executeLanguageModelCall({callId:e,execute:t}){let n=c.modelKeys.get(e);return n===void 0?t():o({idempotencyKey:n,scope:i,type:`model.call`},t)},async onLanguageModelCallEnd(e){let t=c.modelKeys.get(e.callId);if(t===void 0)return;c.modelKeys.delete(e.callId);let n=toModelCallCompleted(c,t,e);await a.publish(n)},async onStepEnd(t){if(t.providerMetadata===void 0)return;let n=c.capturesContent?t.providerMetadata:structuralProviderMetadata(t.providerMetadata);await a.publish(Object.freeze({idempotencyKey:attemptIdempotencyKey(c.scope),providerMetadata:n,scope:c.scope,type:`step.attempt.metadata`}))},async onToolExecutionStart(e){let t=toolCallIdempotencyKey(c.scope,e.toolCall.toolCallId,c.stepNumber??0);c.toolKeys.set(e.toolCall.toolCallId,t);let r=toToolCallStarted(c,t,e);await a.publish(r)},executeTool({toolCallId:e,execute:t}){let n=c.toolKeys.get(e);return n===void 0?t():o({idempotencyKey:n,scope:i,type:`tool.call`},t)},async onToolExecutionEnd(e){let t=e.toolCall.toolCallId,n=c.toolKeys.get(t);if(n===void 0)return;c.toolKeys.delete(t);let r=toToolCallCompleted(c,n,e);await a.publish(r)},async onAbort(e){await failOpenOperations(e.reason)},async onError(e){await failOpenOperations(e.error)}};async function failOpenOperations(e){let t=[];for(let n of c.modelKeys.values())t.push(a.publish(Object.freeze({error:e,idempotencyKey:n,scope:i,type:`model.call.failed`})));for(let n of c.toolKeys.values())t.push(a.publish(Object.freeze({error:e,idempotencyKey:n,scope:i,type:`tool.call.failed`})));c.modelKeys.clear(),c.toolKeys.clear(),await Promise.all(t)}}const directRunInContext=(e,t)=>t();function toStepAttemptStarted(t){if(!(t.operation===void 0||t.stepNumber===void 0))return Object.freeze({idempotencyKey:attemptIdempotencyKey(t.scope),operation:t.operation,runtimeContext:t.runtimeContext,scope:t.scope,type:`step.attempt.started`})}function toModelCallStarted(e,t,n){return Object.freeze({idempotencyKey:t,input:e.capturesContent?Object.freeze({instructions:n.instructions,messages:Object.freeze([...n.messages])}):void 0,model:Object.freeze({modelId:n.modelId,provider:n.provider}),runtimeContext:e.runtimeContext,scope:e.scope,type:`model.call.started`})}function toModelCallCompleted(e,t,n){return Object.freeze({content:e.capturesContent?toContentParts(n.content):void 0,finishReason:n.finishReason,idempotencyKey:t,scope:e.scope,type:`model.call.completed`,usage:toUsage(n.usage)})}function toUsage(e){return Object.freeze({inputTokenDetails:Object.freeze({cacheReadTokens:e.inputTokenDetails?.cacheReadTokens,cacheWriteTokens:e.inputTokenDetails?.cacheWriteTokens}),inputTokens:e.inputTokens,outputTokens:e.outputTokens})}function toContentParts(e){let t=[];for(let n of e)switch(n.type){case`text`:case`reasoning`:t.push(Object.freeze({text:n.text,type:n.type}));break;case`tool-call`:t.push(Object.freeze({callId:n.toolCallId,input:n.input,toolName:n.toolName,type:`tool-call`}));break;case`tool-result`:t.push(Object.freeze({callId:n.toolCallId,input:n.input,output:n.output,toolName:n.toolName,type:`tool-result`}));break;case`tool-error`:t.push(Object.freeze({callId:n.toolCallId,error:n.error,input:n.input,toolName:n.toolName,type:`tool-error`}));break;default:break}return Object.freeze(t)}function toToolCallStarted(e,t,n){return Object.freeze({callId:n.toolCall.toolCallId,idempotencyKey:t,input:e.capturesContent?n.toolCall.input:void 0,scope:e.scope,toolName:n.toolCall.toolName,type:`tool.call.started`})}function toToolCallCompleted(e,t,n){return Object.freeze({idempotencyKey:t,output:toToolOutput(n.toolOutput,e.capturesContent),scope:e.scope,type:`tool.call.completed`})}function toToolOutput(e,t){return e.type===`tool-result`?Object.freeze(t?{output:e.output,type:`result`}:{type:`result`}):Object.freeze(t?{error:e.error,type:`error`}:{type:`error`})}export{createAiSdkHookBridge};

package/dist/src/harness/ai-sdk-telemetry.js

@@ -1 +0,0 @@
-import{registerTelemetry}from"ai";import{OpenTelemetry}from"#compiled/@ai-sdk/otel/index.js";let registered=!1;function ensureOtelIntegration(){registered||(registered=!0,registerTelemetry(new OpenTelemetry({runtimeContext:!0})))}function getRegisteredTelemetryIntegrations(){return globalThis.AI_SDK_TELEMETRY_INTEGRATIONS??[]}export{ensureOtelIntegration,getRegisteredTelemetryIntegrations};

package/dist/src/harness/channel-delivery-instrumentation.js

@@ -1 +0,0 @@
-import{normalizeChannelAudience}from"#shared/channel-audience.js";import{ActiveChannelDeliveriesKey,ChannelInstrumentationKey,ParentTraceContextKey,SessionTraceSeedKey}from"#context/keys.js";import{instrumentationHooksForAudience,instrumentationHooksForDecision}from"#harness/instrumentation/content-policy.js";import{channelDeliveryIdempotencyKey}from"#harness/instrumentation/lifecycle.js";async function instrumentChannelDelivery(i){if(!(`delivery`in i)){let n=i.ctx.get(ActiveChannelDeliveriesKey);if(n===void 0||i.hooks===void 0)return;let r=`channel.delivery.${i.outcome}`;for(let t of n)await hooksForContext(i.ctx,i.hooks,normalizeChannelAudience(t.delivery.channelAudience))?.publish({agentName:t.agentName,delivery:t.delivery,error:i.error,errorCode:i.errorCode,idempotencyKey:channelDeliveryIdempotencyKey(t.sessionId,t.delivery.deliveryId),outcome:i.outcome,rootSessionId:t.rootSessionId,sequence:i.includeTurn?t.sequence:void 0,sessionId:t.sessionId,turnId:i.includeTurn?t.turnId:void 0,type:r});i.ctx.delete(ActiveChannelDeliveriesKey);return}if(i.hooks===void 0||i.delivery.deliveryMetadata===void 0)return;let a=[],o=normalizeChannelAudience(i.ctx.get(ChannelInstrumentationKey)?.metadata.audience),s=hooksForContext(i.ctx,i.hooks,o);for(let e of i.delivery.deliveryMetadata){let t=i.delivery.payloads[e.payloadIndex],n={channelAudience:o,channelKind:e.channelKind,channelName:e.channelName,deliveryId:e.deliveryId,requestId:e.requestId,requestTraceContext:e.requestTraceContext},c=!s?.capturesContent||t===void 0?void 0:projectDeliveryInput(t),l={agentName:i.agentName,delivery:n,rootSessionId:i.rootSessionId,sequence:i.sequence,sessionId:i.sessionId,turnId:i.turnId};a.push(l),await s?.publish({agentName:l.agentName,delivery:n,idempotencyKey:channelDeliveryIdempotencyKey(i.sessionId,n.deliveryId),input:c,parentTraceContext:i.ctx.get(ParentTraceContextKey),rootSessionId:i.rootSessionId,sessionId:i.sessionId,traceSeed:i.ctx.get(SessionTraceSeedKey),type:`channel.delivery.started`})}a.length>0&&i.ctx.set(ActiveChannelDeliveriesKey,a)}function hooksForContext(e,t,n){let r=e.get(SessionTraceSeedKey)?.decision;return r===void 0?instrumentationHooksForAudience(t,n):instrumentationHooksForDecision(t,r,n)}function projectDeliveryInput(e){let t={};return e.context!==void 0&&(t.context=e.context),e.message!==void 0&&(t.message=e.message),e.outputSchema!==void 0&&(t.outputSchema=e.outputSchema),e.inputResponses!==void 0&&(t.inputResponses=e.inputResponses.map(e=>{let t={};return e.optionId!==void 0&&(t.optionId=e.optionId),e.text!==void 0&&(t.text=e.text),t})),t}function channelDeliveryErrorCode(e){if(typeof e==`object`&&e&&`code`in e){let t=e.code;if(typeof t==`string`&&t.length>0)return t}return`CHANNEL_DELIVERY_FAILED`}export{channelDeliveryErrorCode,instrumentChannelDelivery};

package/dist/src/harness/instrumentation/config.js

@@ -1 +0,0 @@
-import{registerInstrumentationRuntime}from"#harness/instrumentation/runtime.js";import{createInstrumentationHooks}from"#harness/instrumentation/lifecycle.js";import{createInstrumentationSetupContext}from"#harness/instrumentation/setup-context.js";const INSTRUMENTATION_CONFIG_GLOBAL_KEY=Symbol.for(`eve.harness-instrumentation-config`),globalContainer=globalThis;async function registerInstrumentationConfig(n,r){globalContainer[INSTRUMENTATION_CONFIG_GLOBAL_KEY]=n,registerInstrumentationRuntime({forceFlush:async()=>void 0,hooks:createInstrumentationHooks([]),otelSettings:{functionId:n.functionId,recordInputs:n.recordInputs===!0,recordOutputs:n.recordOutputs===!0,traceChannelRequests:n.traceChannelRequests===!0},runInContext:(e,t)=>t(),shutdown:async()=>void 0}),await n.setup?.(createInstrumentationSetupContext(r.agentName))}function getInstrumentationConfig(){return globalContainer[INSTRUMENTATION_CONFIG_GLOBAL_KEY]}export{getInstrumentationConfig,registerInstrumentationConfig};

package/dist/src/harness/instrumentation/content-policy.d.ts

@@ -1,7 +0,0 @@
-import type { InstrumentationHooks } from "#harness/instrumentation/lifecycle.js";
-import type { ChannelAudience } from "#shared/channel-audience.js";
-import type { InstrumentationDecision } from "#shared/instrumentation-decision.js";
-export { shouldCaptureInstrumentationContent } from "#shared/instrumentation-content.js";
-export declare function instrumentationHooksForDecision(hooks: InstrumentationHooks | undefined, decision: InstrumentationDecision, audience: ChannelAudience): InstrumentationHooks | undefined;
-/** Applies the audience ceiling before any content-capable provider sees an event. */
-export declare function instrumentationHooksForAudience(hooks: InstrumentationHooks | undefined, audience: ChannelAudience): InstrumentationHooks | undefined;

package/dist/src/harness/instrumentation/content-policy.js

@@ -1 +0,0 @@
-import{withInstrumentationDecision,withoutInstrumentationContent}from"#harness/instrumentation/content.js";import{applyAudienceCeiling,shouldCaptureInstrumentationContent,shouldCaptureInstrumentationContent as shouldCaptureInstrumentationContent$1}from"#shared/instrumentation-content.js";function instrumentationHooksForDecision(t,r,i){if(r.action===`drop`)return instrumentationHooksForAudience(t,i);let a=applyAudienceCeiling(r,i);return a.action===`drop`||t===void 0||!t.capturesContent||a.recordInputs&&a.recordOutputs?t:{capturesContent:a.recordInputs||a.recordOutputs,publish:n=>t.publish(withInstrumentationDecision(n,a))}}function instrumentationHooksForAudience(e,n){return e===void 0||!e.capturesContent||shouldCaptureInstrumentationContent$1(n)?e:{capturesContent:!1,publish:n=>e.publish(withoutInstrumentationContent(n))}}export{instrumentationHooksForAudience,instrumentationHooksForDecision,shouldCaptureInstrumentationContent};

package/dist/src/harness/instrumentation/dispatch.js

@@ -1 +0,0 @@
-import{createLogger,formatError}from"#internal/logging.js";import{abandonInstrumentationState,instrumentationStateSlot,isInstrumentationStateAbandoned,releaseAllInstrumentationAttemptState,releaseAllInstrumentationState,releaseAllInstrumentationTurnState,takeInstrumentationActionScopes}from"#harness/instrumentation/state.js";import{withoutInstrumentationContent}from"#harness/instrumentation/content.js";const log=createLogger(`harness.instrumentation-dispatch`);function createInstrumentationDispatcher(e,t){let n=t.handlerTimeoutMs??5e3,r=normalizeDispatchGroups(e),i=new WeakMap,a=[...r.serialBefore,...r.parallel,...r.serialAfter].some(e=>e.capture===`content`),publish=async e=>{let t=snapshotInstrumentationEvent(e,i),a=t.type===`session.completed`||t.type===`session.failed`,o=t.type===`turn.cancelled`||t.type===`turn.failed`;if(a||o){let e=takeInstrumentationActionScopes(t.sessionId,o?t.turnId:void 0),n=terminalActionFailure(t);for(let t of e)await publish({...n,idempotencyKey:t.idempotencyKey,scope:t.scope,type:`action.failed`})}let s,visibleEvent=e=>e.capture===`content`?t:(s??=withoutInstrumentationContent(t),s);try{try{for(let e of r.serialBefore)await dispatchToProvider(e,t,n,()=>visibleEvent(e));if(r.parallel.length===1){let e=r.parallel[0];await dispatchToProvider(e,t,n,()=>visibleEvent(e))}else if(r.parallel.length>1){let e=(await Promise.allSettled(r.parallel.map(e=>dispatchToProvider(e,t,n,()=>visibleEvent(e))))).find(e=>e.status===`rejected`);if(e!==void 0)throw e.reason}}finally{for(let e of r.serialAfter)await dispatchToProvider(e,t,n,()=>visibleEvent(e))}}finally{releaseTerminalState(t)}};return{capturesContent:a,publish}}function snapshotInstrumentationEvent(e,t){return snapshotPlainValue(e,t)}function snapshotPlainValue(e,t){if(Array.isArray(e)){let n=t.get(e);if(n!==void 0)return n;let r=[];t.set(e,r);for(let n of e)r.push(snapshotPlainValue(n,t));return Object.freeze(r)}if(typeof e!=`object`||!e)return e;let n;try{n=Object.getPrototypeOf(e)}catch{return e}if(n!==Object.prototype&&n!==null)return e;let r=t.get(e);if(r!==void 0)return r;let i={};t.set(e,i);for(let[n,r]of Object.entries(e))i[n]=snapshotPlainValue(r,t);return Object.freeze(i)}function normalizeDispatchGroups(e){if(!Array.isArray(e)){let t=e;return{parallel:t.parallel??[],serialAfter:t.serialAfter??[],serialBefore:t.serialBefore??[]}}return{parallel:[],serialAfter:[],serialBefore:e.map((e,t)=>({...e,name:e.name??`provider-${String(t)}`}))}}async function dispatchToProvider(e,a,o,s){let c=a.type.endsWith(`.started`)||a.type===`input.requested`,l=stateOwner(a),u=e.name,d=e.stateNamespace??u;if(isInstrumentationStateAbandoned(d,a.idempotencyKey))return;let f=e.events?.[a.type];if(f===void 0)return;let p=instrumentationStateSlot(d,a.idempotencyKey,l);try{await withTimeout(()=>f(s(),{state:p}),o,()=>{p.revoke(),c&&abandonInstrumentationState(d,a.idempotencyKey,l)})||log.warn(`instrumentation provider timed out`,{boundary:a.type,provider:u,timeoutMs:o})}catch(e){log.warn(`instrumentation provider failed`,{boundary:a.type,error:formatError(e),provider:u})}finally{p.revoke()}}async function withTimeout(e,t,n){let r;try{return await Promise.race([Promise.resolve(e()).then(()=>!0),new Promise(e=>{r=setTimeout(()=>{n(),e(!1)},t)})])}finally{clearTimeout(r)}}function stateOwner(e){return e.type===`channel.delivery.started`||e.type===`channel.delivery.cancelled`||e.type===`channel.delivery.completed`||e.type===`channel.delivery.failed`?{sessionId:e.sessionId,turnId:e.turnId}:`scope`in e?e.type.startsWith(`action.`)||e.type.startsWith(`input.`)?{sessionId:e.scope.sessionId,turnId:e.scope.turnId}:e.type.startsWith(`model.call.`)||e.type.startsWith(`tool.call.`)||e.type.startsWith(`step.attempt.`)?{attemptId:e.scope.attemptId}:{}:{}}function releaseTerminalState(e){isTerminal(e.type)&&releaseAllInstrumentationState(e.idempotencyKey),(e.type===`step.attempt.completed`||e.type===`step.attempt.failed`)&&releaseAllInstrumentationAttemptState(e.scope.attemptId),(e.type===`session.completed`||e.type===`session.failed`)&&releaseAllInstrumentationTurnState(e.sessionId),(e.type===`turn.cancelled`||e.type===`turn.failed`)&&releaseAllInstrumentationTurnState(e.sessionId,e.turnId)}function terminalActionFailure(e){return e.type===`session.failed`||e.type===`turn.failed`?{error:e.error,outcome:`failed`}:e.type===`turn.cancelled`?{error:Error(`The action was cancelled with its turn.`),errorCode:`ACTION_CANCELLED`,outcome:`cancelled`}:{error:Error(`The session completed before the action settled.`),errorCode:`ACTION_ABANDONED`,outcome:`abandoned`}}function isTerminal(e){return e.endsWith(`.completed`)||e.endsWith(`.failed`)||e.endsWith(`.cancelled`)||e===`input.resolved`}export{createInstrumentationDispatcher};

package/dist/src/harness/instrumentation/lifecycle.js

@@ -1 +0,0 @@
-import{createInstrumentationDispatcher}from"#harness/instrumentation/dispatch.js";function sessionIdempotencyKey(e){return`session:${e}`}function turnIdempotencyKey(e,t){return`turn:${e}:${t}`}function attemptIdempotencyKey(e){return`step:${e.attemptId}`}function modelCallIdempotencyKey(e,t){return`model:${e.attemptId}:${String(t)}`}function toolCallIdempotencyKey(e,t,n){return`tool:${e.attemptId}:${t}:${String(n)}`}function inputIdempotencyKey(e,t,n){return`input:${e}:${t}:${n}`}function channelDeliveryIdempotencyKey(e,t){return`channel-delivery:${e}:${t}`}function actionIdempotencyKey(e,t,n){return`action:${e}:${t}:${n}`}function createInstrumentationHooks(t,n={}){return createInstrumentationDispatcher(t,n)}export{actionIdempotencyKey,attemptIdempotencyKey,channelDeliveryIdempotencyKey,createInstrumentationHooks,inputIdempotencyKey,modelCallIdempotencyKey,sessionIdempotencyKey,toolCallIdempotencyKey,turnIdempotencyKey};

package/dist/src/harness/instrumentation/native-events.js

@@ -1 +0,0 @@
-import{contextStorage}from"#context/container.js";import{instrumentChannelDelivery}from"#harness/channel-delivery-instrumentation.js";import{rememberInstrumentationActionScope,rememberInstrumentationInputScope,takeInstrumentationActionScopeForCall,takeInstrumentationInputScope}from"#harness/instrumentation/state.js";import{RuntimeActionSettlementTimesKey}from"#harness/runtime-action-settlement-state.js";import{actionIdempotencyKey,inputIdempotencyKey,sessionIdempotencyKey,turnIdempotencyKey}from"#harness/instrumentation/lifecycle.js";function createInstrumentationHandleEvent(n){if(n.hooks===void 0)return n.handleEvent;if(n.handleEvent===void 0)return;let r=n.handleEvent,i=n.hooks,a=new Set,o=new Set,s=n.turnId;return async(c,l)=>{await r(c,l);let u=toLifecycleEvent(c,n,s);if(c.type===`turn.started`&&(s=c.data.turnId),c.type===`turn.cancelled`||c.type===`turn.completed`||c.type===`turn.failed`||c.type===`session.completed`||c.type===`session.failed`){let n=contextStorage.getStore();n!==void 0&&await instrumentChannelDelivery({ctx:n,error:c.type===`turn.failed`||c.type===`session.failed`?Error(c.data.message):void 0,errorCode:c.type===`turn.failed`||c.type===`session.failed`?c.data.code:void 0,hooks:i,includeTurn:c.type===`turn.cancelled`||c.type===`turn.completed`||c.type===`turn.failed`,outcome:c.type===`turn.failed`||c.type===`session.failed`?`failed`:c.type===`turn.cancelled`?`cancelled`:`completed`})}u!==void 0&&await i.publish(u),c.type===`actions.requested`?await publishActionStarts(c,n,i,a):c.type===`action.result`?await publishActionTerminal(c,n,i):c.type===`input.requested`&&await publishInputStarts(c,n,i,o)}}async function publishInputStarts(e,t,n,i){let a=t.getAttemptScope?.();if(a!==void 0)for(let o of e.data.requests){let s=inputIdempotencyKey(t.sessionId,e.data.turnId,o.requestId);i.has(s)||(i.add(s),rememberInstrumentationInputScope(s,a),await n.publish(Object.freeze({action:Object.freeze({callId:o.action.callId,name:o.action.toolName}),idempotencyKey:s,kind:o.kind,request:n.capturesContent?Object.freeze({allowFreeform:o.allowFreeform,display:o.display,options:o.options,prompt:o.prompt}):void 0,requestId:o.requestId,scope:a,type:`input.requested`})))}}async function publishInputResolutions(e){for(let t of e.batch.inputs){let n=inputIdempotencyKey(e.sessionId,e.batch.event.turnId,t.request.requestId),r=takeInstrumentationInputScope(n);r!==void 0&&await e.hooks.publish(Object.freeze({idempotencyKey:n,kind:t.request.kind,outcome:t.outcome,requestId:t.request.requestId,response:!e.hooks.capturesContent||t.response===void 0?void 0:Object.freeze({optionId:t.response.optionId,text:t.response.text}),scope:r,type:`input.resolved`}))}}async function publishActionStarts(e,t,r,i){let a=t.getAttemptScope?.();if(a!==void 0)for(let o of e.data.actions){let c=actionIdempotencyKey(t.sessionId,e.data.turnId,o.callId);i.has(c)||(i.add(c),rememberInstrumentationActionScope(c,a),await r.publish(Object.freeze({callId:o.callId,idempotencyKey:c,input:r.capturesContent?o.input:void 0,kind:o.kind,name:actionName(o),scope:a,type:`action.started`})))}}async function publishActionTerminal(t,n,r){let a=takeInstrumentationActionScopeForCall(n.sessionId,t.data.result.callId);if(a===void 0)return;let{idempotencyKey:s,scope:c}=a;if(t.data.status===`completed`){await r.publish(Object.freeze({acceptedAtMs:contextStorage.getStore()?.get(RuntimeActionSettlementTimesKey)?.[t.data.result.callId],idempotencyKey:s,outcome:`completed`,output:Object.freeze(r.capturesContent?{output:t.data.result.output,type:`result`}:{type:`result`}),scope:c,type:`action.completed`,usage:actionUsage(t.data.result)}));return}let l=t.data.error===void 0?t.data.result.output:Object.assign(Error(t.data.error.message),{code:t.data.error.code});await r.publish(Object.freeze({acceptedAtMs:contextStorage.getStore()?.get(RuntimeActionSettlementTimesKey)?.[t.data.result.callId],error:l,errorCode:t.data.error?.code,idempotencyKey:s,outcome:t.data.status,scope:c,type:`action.failed`}))}function actionUsage(e){if(!(e.kind!==`subagent-result`||e.origin!==`child`||e.usage===void 0))return{inputTokenDetails:{cacheReadTokens:e.usage.cacheReadTokens,cacheWriteTokens:e.usage.cacheWriteTokens},inputTokens:e.usage.inputTokens,outputTokens:e.usage.outputTokens}}function actionName(e){return e.kind===`tool-call`?e.toolName:e.kind===`load-skill`?`load_skill`:e.name}function toLifecycleEvent(e,t,n){switch(e.type){case`session.started`:return{agentName:t.agentName,channelAudience:t.channelAudience,channelKind:t.channelKind,idempotencyKey:sessionIdempotencyKey(t.sessionId),parentTraceContext:t.parentTraceContext,rootSessionId:t.rootSessionId??t.sessionId,sessionId:t.sessionId,type:`session.started`};case`session.completed`:case`session.waiting`:return{idempotencyKey:sessionIdempotencyKey(t.sessionId),sessionId:t.sessionId,turnId:n,type:e.type};case`session.failed`:return{error:Error(e.data.message),idempotencyKey:sessionIdempotencyKey(t.sessionId),sessionId:t.sessionId,turnId:n,type:`session.failed`};case`turn.started`:return{idempotencyKey:turnIdempotencyKey(t.sessionId,e.data.turnId),parentLineage:t.parentLineage,parentTraceContext:t.parentTraceContext,rootSessionId:t.rootSessionId??t.sessionId,sequence:e.data.sequence,sessionId:t.sessionId,turnId:e.data.turnId,type:`turn.started`};case`turn.completed`:case`turn.cancelled`:return{idempotencyKey:turnIdempotencyKey(t.sessionId,e.data.turnId),sessionId:t.sessionId,turnId:e.data.turnId,type:e.type};case`turn.failed`:return{error:Error(e.data.message),idempotencyKey:turnIdempotencyKey(t.sessionId,e.data.turnId),sessionId:t.sessionId,turnId:e.data.turnId,type:`turn.failed`};default:return}}export{createInstrumentationHandleEvent,publishInputResolutions};

package/dist/src/harness/instrumentation/providers.js

@@ -1 +0,0 @@
-import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{getInstrumentationRuntime}from"#harness/instrumentation/runtime.js";import{DEVELOPMENT_WORKER_APP_ROOT_ENV}from"#internal/workflow/development-world-protocol.js";import{createInstrumentationSetupContext}from"#harness/instrumentation/setup-context.js";import{agentRuns,localTraces}from"#public/instrumentation/otel.js";import{installInstrumentationRuntime}from"#tracing/install-instrumentation-runtime.js";import{collectOtelPipeline}from"#tracing/otel-declaration.js";import{isInstrumentationDisabled,isInstrumentationProvider}from"#public/instrumentation/provider.js";const INSTRUMENTATION_PROVIDERS_GLOBAL_KEY=Symbol.for(`eve.harness-instrumentation-providers`),globalContainer=globalThis;function providerRegistry(){let e=globalContainer[INSTRUMENTATION_PROVIDERS_GLOBAL_KEY];if(e!==void 0)return e;let t=new Map;return globalContainer[INSTRUMENTATION_PROVIDERS_GLOBAL_KEY]=t,t}function seedInstrumentationProviders(){let e=providerRegistry();process.env.VERCEL_ENV===`production`&&e.set(`agent-runs`,agentRuns()),process.env[DEVELOPMENT_WORKER_APP_ROOT_ENV]!==void 0&&e.set(`local`,localTraces())}async function registerInstrumentationProvider(e){if(isInstrumentationDisabled(e.value)){providerRegistry().delete(e.slot);return}if(!isInstrumentationProvider(e.value))throw Error(`The default export of "instrumentation/${e.slot}" is not an instrumentation provider. Return the result of \`defineInstrumentation\` or \`disableInstrumentation\` from it.`);providerRegistry().set(e.slot,e.value),await e.value.setup?.(createInstrumentationSetupContext(e.agentName))}function getInstrumentationProviders(){return[...providerRegistry()].sort(([e],[t])=>e.localeCompare(t)).map(([e,t])=>({provider:t,slot:e}))}function finalizeInstrumentationProviders(t){let n=getInstrumentationProviders(),r=n.map(toProviderDefinition),i=collectOtelPipeline(n.map(e=>e.provider));return installInstrumentationRuntime({collected:i,frameworkVersion:resolveInstalledPackageInfo().version,providers:r,runtimeContextResolvers:i.runtimeContextResolvers,serviceName:t.serviceName})}async function shutdownInstrumentationProviders(){await getInstrumentationRuntime()?.shutdown()}function toProviderDefinition(e){return{capture:e.provider.capture,events:e.provider.events,flush:e.provider.flush,name:e.slot,shutdown:e.provider.shutdown,stateNamespace:`authored:${e.slot}`}}export{finalizeInstrumentationProviders,getInstrumentationProviders,registerInstrumentationProvider,seedInstrumentationProviders,shutdownInstrumentationProviders};

package/dist/src/harness/instrumentation/runtime-context.js

@@ -1 +0,0 @@
-import{createLogger,formatError}from"#internal/logging.js";import{normalizeInstrumentationChannelKind,resolveInstrumentationProjection}from"#internal/instrumentation.js";import{normalizeChannelAudience}from"#shared/channel-audience.js";import{contextStorage}from"#context/container.js";import{AuthKey,ChannelInstrumentationKey,InitiatorAuthKey,ParentSessionKey}from"#context/keys.js";import{parseJsonObject,parseJsonValue}from"#shared/json.js";import{shouldCaptureInstrumentationContent}from"#harness/instrumentation/content-policy.js";const log=createLogger(`harness.instrumentation-runtime-context`);function buildTelemetryRuntimeContext(e){let t=e.authored!==void 0,r=e.providerResolvers!==void 0&&e.providerResolvers.length>0;if(!t&&!r)return;let i=resolveStepStartedRuntimeContext(e),o=resolveProviderRuntimeContext(e),c=contextStorage.getStore()?.get(ChannelInstrumentationKey);return{...i,...o,"eve.channel.kind":normalizeInstrumentationChannelKind(c?.kind),"eve.environment":e.environment,"eve.session.id":e.session.sessionId,"eve.step.index":String(e.emissionState.stepIndex),"eve.turn.id":e.emissionState.turnId,"eve.turn.sequence":String(e.emissionState.sequence),"eve.version":e.eveVersion}}function buildInstrumentationStepStartedInput(e){let t=contextStorage.getStore(),r=t?.get(ChannelInstrumentationKey),o=shouldCaptureInstrumentationContent(normalizeChannelAudience(r?.metadata.audience));return{channel:{kind:normalizeInstrumentationChannelKind(r?.kind),metadata:snapshotForInstrumentation(r?.metadata,`channel.metadata`)??{}},modelInput:o?snapshotForInstrumentation(e.modelInput,`modelInput`)??{instructions:void 0,messages:[]}:{instructions:void 0,messages:[]},session:{auth:projectSessionAuth(t),id:e.session.sessionId,parent:snapshotForInstrumentation(t?.get(ParentSessionKey),`session.parent`)},step:{index:e.emissionState.stepIndex},turn:{id:e.emissionState.turnId,sequence:e.emissionState.sequence}}}function filterAuthoredRuntimeContext(e,t){let n={};for(let[r,i]of Object.entries(e)){if(r.startsWith(`eve.`)){log.warn(`ignoring reserved instrumentation runtime context key`,{key:r,source:t});continue}n[r]=i}return Object.keys(n).length>0?n:void 0}function resolveStepStartedRuntimeContext(e){let n=e.authored?.events?.[`step.started`];if(n===void 0)return;let i=`events["step.started"]`,a=resolveInstrumentationProjection({invoke:()=>{let t=buildInstrumentationStepStartedInput(e);return n(t)},log,source:i});if(a===void 0)return;if(!(`runtimeContext`in a)){log.warn(`ignoring instrumentation event result because runtimeContext is missing`,{source:i});return}let o;try{o=parseJsonObject(a.runtimeContext)}catch(e){log.warn(`ignoring instrumentation event result because runtimeContext is invalid`,{error:formatError(e),source:i});return}return filterAuthoredRuntimeContext(o,i)}function resolveProviderRuntimeContext(e){let t=e.providerResolvers;if(t===void 0||t.length===0)return;let n={},i=!1;for(let a of t){let t=`provider.runtimeContext`,o=resolveInstrumentationProjection({invoke:()=>{let t=buildInstrumentationStepStartedInput(e);return a(t)},log,source:t});if(o===void 0)continue;let s=filterAuthoredRuntimeContext(o,t);s!==void 0&&(Object.assign(n,s),i=!0)}return i?n:void 0}function projectSessionAuth(e){let t=e?.get(AuthKey)??null,n=e?.get(InitiatorAuthKey)??t;return{current:snapshotForInstrumentation(t,`session.auth.current`)??null,initiator:snapshotForInstrumentation(n,`session.auth.initiator`)??null}}function snapshotForInstrumentation(e,n){if(e!==void 0)try{return parseJsonValue(e)}catch(e){log.warn(`dropping non-serializable instrumentation snapshot`,{error:formatError(e),source:n});return}}export{buildTelemetryRuntimeContext};

package/dist/src/harness/instrumentation/runtime.d.ts

@@ -1,21 +0,0 @@
-import type { InstrumentationContextRunner, InstrumentationHooks, InstrumentationSessionStartedEvent, InstrumentationTraceContext, InstrumentationTurnStartedEvent } from "#harness/instrumentation/lifecycle.js";
-import type { AgentSpanIdGenerator } from "#tracing/agent-span-id-generator.js";
-import type { OtelHarnessSettings, RuntimeContextResolver } from "#tracing/otel-declaration.js";
-/** Process-wide runtime consumed by every harness execution surface. */
-export interface InstrumentationRuntime {
-    readonly forceFlush: () => Promise<void>;
-    readonly hooks: InstrumentationHooks;
-    readonly idGenerator?: AgentSpanIdGenerator;
-    readonly prepareSessionTrace?: (event: InstrumentationSessionStartedEvent) => Promise<InstrumentationTraceContext>;
-    readonly prepareTurnTrace?: (event: InstrumentationTurnStartedEvent) => Promise<InstrumentationTraceContext>;
-    otelSettings: OtelHarnessSettings | undefined;
-    readonly runtimeContextResolvers?: readonly RuntimeContextResolver[];
-    readonly runInContext: InstrumentationContextRunner;
-    readonly shutdown: () => Promise<void>;
-}
-/** Instrumentation capabilities consumed inside one harness execution. */
-export type HarnessInstrumentation = Pick<InstrumentationRuntime, "hooks" | "prepareSessionTrace" | "prepareTurnTrace" | "runInContext">;
-/** Registers the process instrumentation runtime before agent execution begins. */
-export declare function registerInstrumentationRuntime(runtime: InstrumentationRuntime): InstrumentationRuntime;
-/** Returns the process instrumentation runtime, when one was installed. */
-export declare function getInstrumentationRuntime(): InstrumentationRuntime | undefined;

package/dist/src/harness/instrumentation/runtime.js

@@ -1 +0,0 @@
-const INSTRUMENTATION_RUNTIME_KEY=Symbol.for(`eve.instrumentation-runtime`),globalRuntime=globalThis;function registerInstrumentationRuntime(e){let t=globalRuntime[INSTRUMENTATION_RUNTIME_KEY];return t===void 0?(globalRuntime[INSTRUMENTATION_RUNTIME_KEY]=e,e):(t.otelSettings=e.otelSettings,t)}function getInstrumentationRuntime(){return globalRuntime[INSTRUMENTATION_RUNTIME_KEY]}export{getInstrumentationRuntime,registerInstrumentationRuntime};

package/dist/src/harness/prepare-trace-context.d.ts

@@ -1,21 +0,0 @@
-import type { RuntimeTraceContext } from "#protocol/message.js";
-import type { InstrumentationParentLineage, InstrumentationTraceContext } from "#harness/instrumentation/lifecycle.js";
-import type { HarnessInstrumentation } from "#harness/instrumentation/runtime.js";
-import type { ChannelAudience } from "#shared/channel-audience.js";
-import type { SessionTraceSeed } from "#context/keys.js";
-/** Prepares native session/turn tracing before their durable stream events. */
-export declare function prepareTurnTraceContext(input: {
-    readonly agentName?: string;
-    readonly channelAudience?: ChannelAudience;
-    readonly channelType?: string;
-    readonly instrumentation?: HarnessInstrumentation;
-    readonly parentLineage?: InstrumentationParentLineage;
-    readonly parentTraceContext?: InstrumentationTraceContext;
-    readonly rootSessionId: string;
-    readonly sequence: number;
-    readonly sessionId: string;
-    readonly sessionStarted: boolean;
-    readonly traceContext?: RuntimeTraceContext;
-    readonly traceSeed?: SessionTraceSeed;
-    readonly turnId: string;
-}): Promise<RuntimeTraceContext | undefined>;

package/dist/src/harness/prepare-trace-context.js

@@ -1 +0,0 @@
-import{createLogger,formatError}from"#internal/logging.js";import{sessionIdempotencyKey,turnIdempotencyKey}from"#harness/instrumentation/lifecycle.js";const log=createLogger(`harness.prepare-trace-context`);async function prepareTurnTraceContext(e){let t;if(!e.sessionStarted&&e.instrumentation?.prepareSessionTrace!==void 0)try{t=await e.instrumentation.prepareSessionTrace({agentName:e.agentName,channelAudience:e.channelAudience,channelType:e.channelType,idempotencyKey:sessionIdempotencyKey(e.sessionId),parentTraceContext:e.parentTraceContext,rootSessionId:e.rootSessionId,sessionId:e.sessionId,traceSeed:e.traceSeed,type:`session.started`})}catch(e){warn(`session.started`,e)}if(e.instrumentation?.prepareTurnTrace!==void 0)try{t=await e.instrumentation.prepareTurnTrace({idempotencyKey:turnIdempotencyKey(e.sessionId,e.turnId),parentLineage:e.parentLineage,parentTraceContext:e.parentTraceContext,rootSessionId:e.rootSessionId,sequence:e.sequence,sessionId:e.sessionId,turnId:e.turnId,type:`turn.started`})}catch(e){warn(`turn.started`,e)}return e.traceContext??t}function warn(e,n){log.warn(`instrumentation trace preparation failed`,{boundary:e,error:formatError(n)})}export{prepareTurnTraceContext};