eve 0.44.4 → 0.45.0

package/docs/subagents/index.mdx

@@ -3,22 +3,20 @@ title: "Subagents"
 description: "Delegate work to root-agent copies or declared specialists with their own tools and sandbox."
 ---
 
-eve supports two ways to delegate work: the root-only built-in `agent` tool, which runs a fresh copy of the root agent, and declared subagents, which are specialists with their own directories. Use a subagent to run independent work in parallel, narrow the available tools, or give a task to a specialist.
+eve supports two ways to delegate work: the root-only built-in `agent` tool, which starts or continues a copy of the root agent, and declared subagents, which are specialists with their own directories. Use a subagent to run independent work in parallel, narrow the available tools, or give a task to a specialist.
 
 ## The built-in `agent` tool
 
-The root session receives `agent` by default. The model calls it to delegate a task to a fresh copy of the root agent:
+The root session receives `agent` by default. The model calls it to delegate a task to a new copy of the root agent or continue an existing copy:
 
 ```ts
 {
   message: string;       // everything the child needs; it does not see the parent's history
-  agentId?: string;      // only with experimental.subagentPersistentSessions: continue an existing child
-  outputSchema?: object; // when set, the child runs in task mode and returns structured output
+  agentId?: string;      // continue an existing child
+  outputSchema?: object; // require structured output for this turn
 }
 ```
 
-The `agentId` field exists only when the agent opts into [agent messaging](#agent-messaging); without the opt-in the schema is `{ message, outputSchema? }`.
-
 The copy uses the root's instructions, connections, auth, and sandbox. It receives the same tools except for the root-only `agent` and `Workflow`, and starts with fresh conversation history and fresh state. Its file writes are immediately visible to the root. To run independent tasks in parallel, emit multiple `agent` calls in one response; eve runs the batch concurrently and returns every result before the root continues. Give parallel children non-overlapping write scopes.
 
 `agent` is intentionally root-only. Copies created by it cannot call `agent`, and declared subagents never receive the built-in tool. If a stale or forced recursive call reaches execution, eve rejects it instead of starting another child session.
@@ -126,7 +124,7 @@ The root agent does not receive the extension's tools, skills, instructions, con
 
 ## The isolation boundary
 
-A declared subagent inherits nothing from the root's authored slots. Discovery treats its directory as its own agent root, so it has only the instructions, tools, connections, skills, sandbox, hooks, and nested subagents authored under `agent/subagents/<id>/`. An absent slot falls back to the framework default, not to the root's version.
+A declared subagent inherits nothing from the root's authored slots. Discovery treats its directory as its own agent root, so it has only the instructions, tools, connections, skills, sandbox, hooks, and nested subagents authored under `agent/subagents/<id>/`. For a slot with a framework default, eve selects that source when the subagent does not author a replacement; it never inherits the root's authored version.
 
 | Slot         | Root built-in `agent` tool    | Declared subagent                      |
 | ------------ | ----------------------------- | -------------------------------------- |
@@ -141,7 +139,7 @@ A declared subagent inherits nothing from the root's authored slots. Discovery t
 | Channels     | Root-only                     | Root-only                              |
 | Schedules    | Root-only                     | Root-only                              |
 
-For a declared subagent this means authoring or mounting anything the child needs. When two subagents need the same procedure, package the skill in a [workspace extension](./extensions#use-an-extension-in-a-workspace) and mount that extension in each subagent. Share typed helpers through `lib/`. The sandbox does not inherit from the parent; it falls back to the framework default unless the subagent authors `subagents/<id>/sandbox.ts` or seeds files via `subagents/<id>/sandbox/workspace/`.
+For a declared subagent this means authoring or mounting anything the child needs. When two subagents need the same procedure, package the skill in a [workspace extension](./extensions#use-an-extension-in-a-workspace) and mount that extension in each subagent. Share typed helpers through `lib/`. The sandbox does not inherit from the parent; eve selects the default sandbox source unless the subagent authors `subagents/<id>/sandbox.ts` or seeds files via `subagents/<id>/sandbox/workspace/`.
 
 The root built-in `agent` tool is the exception. Its children share the root's sandbox and tools because they are copies of the same agent working on the same files.
 
@@ -149,7 +147,7 @@ The root built-in `agent` tool is the exception. Its children share the root's s
 
 ## What the parent sees
 
-eve lowers every subagent visible to the current agent (the root built-in copy, declared, or [remote](./guides/remote-agents)) into a model-visible tool with the same `{ message, outputSchema? }` shape — plus `agentId` when the agent opts into [agent messaging](#agent-messaging). The parent packs `message` with everything the child needs, since the child never sees the parent's history. Set `outputSchema` to run the child in task mode, returning structured output as the tool result; this works the same with or without agent messaging.
+eve lowers every subagent visible to the current agent (the root built-in copy, declared, or [remote](./guides/remote-agents)) into a model-visible tool with the same `{ message, agentId?, outputSchema? }` shape. The parent packs `message` with everything the child needs, since the child never sees the parent's history. Set `outputSchema` to require structured output for that turn; the child remains available for follow-up messages afterward.
 
 Declared subagents can call nested subagents defined under their own directories. eve does not apply a separate depth limit; nesting ends where the authored directory tree ends. The built-in `agent` follows the stricter root-only rule above, so `limits.maxSubagentDepth` no longer exists.
 
@@ -160,8 +158,8 @@ A directly declared subagent's tool name is the bare path-derived name, with no
 ```ts
 {
   message: string;       // all context the child needs; it never sees the parent's history
-  agentId?: string;      // only with experimental.subagentPersistentSessions: continue an existing child
-  outputSchema?: object; // when set, the child runs in task mode and returns structured output
+  agentId?: string;      // continue an existing child
+  outputSchema?: object; // require structured output for this turn
 }
 ```
 
@@ -177,26 +175,11 @@ Subagent model calls automatically retry classified transient provider failures,
 
 ## Agent messaging
 
-Agent messaging is experimental and off by default. Opt in per agent in `agent.ts`:
-
-```ts title="agent/agent.ts"
-import { defineAgent } from "eve";
-
-export default defineAgent({
-  experimental: {
-    subagentPersistentSessions: true,
-  },
-  model: "anthropic/claude-sonnet-4.5",
-});
-```
-
-Without the opt-in, delegated children run as one-shot tasks: they answer once and terminate, and the subagent tool schema carries no `agentId` field.
-
-With it enabled, a child parks after answering instead of terminating, keeping its session and conversation history alive. A failed child turn can also leave the child parked — its latest status shows the error and the parent may message it again. Pass a parked child's `agentId` to the same subagent tool with a new `message` to continue that session. Omitting `agentId` (or passing an empty string or `null`) always starts a new child, and an `agentId` that matches no known agent falls back to starting a new child rather than failing. Passing a known `agentId` through a different subagent tool fails with `AGENT_MISMATCH`, and messaging a child that is still starting or working on its previous request fails with `AGENT_BUSY` — wait for its result before continuing it.
+A child parks after answering instead of terminating, keeping its session and conversation history alive. A failed child turn can also leave the child parked — its latest status shows the error and the parent may message it again. Pass a parked child's `agentId` to the same subagent tool with a new `message` to continue that session. Omitting `agentId` (or passing an empty string or `null`) always starts a new child, and an `agentId` that matches no known agent falls back to starting a new child rather than failing. Passing a known `agentId` through a different subagent tool fails with `AGENT_MISMATCH`, and messaging a child that is still starting or working on its previous request fails with `AGENT_BUSY` — wait for its result before continuing it.
 
 Whenever the set of parked (resumable) children changes, eve appends a framework-injected note to the conversation — labeled `[Agents]` and carrying an `<agents>` block — listing each child's `agentId`, name, and latest status. The static system prompt tells the model the note is injected by eve, not written by the user. The note is appended only when the listing changes (an append-only design that preserves the provider prompt cache), the most recent note is authoritative, and children that are starting or running do not appear until they park again.
 
-The parent holds agent handles only for its session lifetime. When the parent session ends, eve terminates its local children. Remote children are not terminated on parent shutdown — that is a known gap: a parked remote child stays alive on its own deployment until that deployment's own lifecycle ends it. For [remote agents](./guides/remote-agents), both deployments must run the same eve version to use agent messaging.
+The parent holds agent handles only for its session lifetime. When the parent session ends, eve terminates local children and sends authenticated reset requests for remote children. Remote reset is best-effort: an unreachable deployment may retain the parked child until its own session deadline. For [remote agents](./guides/remote-agents), upgrade both deployments before relying on continuation or reset behavior introduced by a newer eve version.
 
 ## When to split
 

package/docs/tools/human-in-the-loop.md

@@ -52,10 +52,51 @@ approval: ({ session, toolInput }) => {
 
 For compatibility with the previous predicate shape, policies may return booleans: `true` is treated as `"user-approval"` and `false` as `"not-applicable"`. Boolean promises are supported too.
 
-Policies can also return `"approved"` or `"denied"` to decide automatically. Use `{ type: "approved" | "denied", reason }` when the model should receive a reason. The `Approval`, `ApprovalContext`, and `ApprovalStatus` types are exported from both `eve/tools` and `eve/tools/approval`.
+Policies can also return `"approved"` or `"denied"` to decide automatically. Use `{ type: "approved" | "denied", reason }` when the model should receive a reason. The `Approval`, `ApprovalContext`, and `ApprovalStatus` types are exported from `eve/tools/approval`.
 
 Gating a side effect on approval is also how you make non-idempotent work safe across replays: a charge or email that sits behind `always()` can't fire from a re-run step without a fresh human decision.
 
+### Authorizing approval responses
+
+You may also define an approval response policy that decides whether the authenticated person who selects **Approve** may approve that specific call:
+
+```ts title="agent/tools/refund_charge.ts"
+import { defineTool } from "eve/tools";
+import { always } from "eve/tools/approval";
+import { z } from "zod";
+
+export default defineTool({
+  description: "Refund a charge.",
+  inputSchema: z.object({ chargeId: z.string() }),
+  approval: {
+    request: always(),
+    response: ({ responder, request, response, session, auth }) => {
+      // The Slack channel authenticates the responder and includes the workspace and user IDs.
+      // Larger apps can look up approver membership here instead.
+      const approvers = ["slack:T012AB3CD:U045EF6GH", "slack:T012AB3CD:U078JK9LM"];
+      const canApprove = approvers.includes(responder.principalId);
+
+      return canApprove
+        ? { status: "allowed" }
+        : { status: "rejected", reason: "This user cannot approve refunds." };
+    },
+  },
+  async execute(input) {
+    return refund(input);
+  },
+});
+```
+
+The `response` policy receives:
+
+- `responder`: the authenticated principal that submitted the response, including its `principalId`, `principalType`, `authenticator`, and `attributes`. Your route or channel supplies this identity.
+- `request`: the stable `requestId`, `callId`, `toolName`, and typed `toolInput` for the call being approved.
+- `response`: the submitted decision. Response policies run for approval, so its current value is `{ decision: "approve" }`.
+- `session`: read-only session identity and lineage: `id`, `initiator`, `parent`, and `turn`.
+- `auth`: narrow `getToken(provider, options?)` and `requireAuth(provider, options?)` capabilities bound to the responder. Use these when authorization depends on a provider identity or permission; an interactive provider flow parks durably and then retries the policy.
+
+Return `{ status: "allowed" }` to accept the approval. Return `{ status: "rejected", reason }` to leave the shared request pending so another eligible responder can approve it.
+
 ### Skipping approval for schedule-dispatched turns
 
 `session.auth.current` identifies the caller of this turn. Markdown schedules use the app principal (`authenticator: "app"`, `principalId: "eve:app"`, `principalType: "runtime"`) automatically. A `run` schedule must pass its `appAuth` to `send(...)` for the child session to use that principal. Match all three fields to skip approval for automated turns while still prompting when a person calls the same tool:
@@ -111,7 +152,7 @@ The run picks back up exactly where it parked. Because the pause is durable, not
 
 When a background subagent requests input, eve emits the same `input.requested` event on its parent session. Answering through that parent session routes the response directly to the blocked child without invoking the parent model.
 
-For approval requests, unrelated follow-up text does not deny the tool call. eve keeps the approval pending and records that pending state in model-visible session history. Follow-up turns may answer with text, but cannot call tools until the approval is resolved. Once it is answered, normal tool use resumes and eve settles the original tool call exactly once.
+For approval requests, unrelated follow-up text does not deny the tool call. eve keeps the approval pending and records that pending state in model-visible session history. Follow-up turns run normally and may call other tools while the approval remains unresolved. Once it is answered, eve settles the original tool call exactly once.
 
 See [Sessions, runs & streaming](/docs/concepts/sessions-runs-and-streaming) for the full event and resume contract that this builds on.
 

package/docs/tools/overview.mdx

@@ -4,7 +4,7 @@ description: "Define typed actions the agent can call, and gate sensitive ones o
 url: /tools
 ---
 
-A tool is a typed action the agent can call, such as hitting an API, running a query, or writing a file. The action stays in code you control. Tools run in your app runtime with full access to `process.env`, not in the [sandbox](/docs/sandbox).
+A tool is a typed action the agent can call, such as hitting an API, running a query, or writing a file. Define a tool when you implement the action in code you control. To give the model tools published by an external MCP or OpenAPI service, use a [connection](/docs/connections) instead. Authored tools run in your app runtime with full access to `process.env`, not in the [sandbox](/docs/sandbox).
 
 ## Define a tool
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.44.4",
+  "version": "0.45.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -102,19 +102,64 @@
       "default": "./dist/src/public/tools/approval/index.js"
     },
     "./tools/sleep": {
-      "types": "./dist/src/public/tools/sleep/index.d.ts",
-      "import": "./dist/src/public/tools/sleep/index.js",
-      "default": "./dist/src/public/tools/sleep/index.js"
+      "types": "./dist/src/public/tools/sleep.d.ts",
+      "import": "./dist/src/public/tools/sleep.js",
+      "default": "./dist/src/public/tools/sleep.js"
     },
     "./tools": {
       "types": "./dist/src/public/tools/index.d.ts",
       "import": "./dist/src/public/tools/index.js",
       "default": "./dist/src/public/tools/index.js"
     },
-    "./tools/defaults": {
-      "types": "./dist/src/public/tools/defaults.d.ts",
-      "import": "./dist/src/public/tools/defaults.js",
-      "default": "./dist/src/public/tools/defaults.js"
+    "./tools/bash": {
+      "types": "./dist/src/public/tools/bash.d.ts",
+      "import": "./dist/src/public/tools/bash.js",
+      "default": "./dist/src/public/tools/bash.js"
+    },
+    "./tools/read_file": {
+      "types": "./dist/src/public/tools/read-file.d.ts",
+      "import": "./dist/src/public/tools/read-file.js",
+      "default": "./dist/src/public/tools/read-file.js"
+    },
+    "./tools/write_file": {
+      "types": "./dist/src/public/tools/write-file.d.ts",
+      "import": "./dist/src/public/tools/write-file.js",
+      "default": "./dist/src/public/tools/write-file.js"
+    },
+    "./tools/todo": {
+      "types": "./dist/src/public/tools/todo.d.ts",
+      "import": "./dist/src/public/tools/todo.js",
+      "default": "./dist/src/public/tools/todo.js"
+    },
+    "./tools/web_fetch": {
+      "types": "./dist/src/public/tools/web-fetch.d.ts",
+      "import": "./dist/src/public/tools/web-fetch.js",
+      "default": "./dist/src/public/tools/web-fetch.js"
+    },
+    "./tools/web_search": {
+      "types": "./dist/src/public/tools/web-search.d.ts",
+      "import": "./dist/src/public/tools/web-search.js",
+      "default": "./dist/src/public/tools/web-search.js"
+    },
+    "./tools/load_skill": {
+      "types": "./dist/src/public/tools/load-skill.d.ts",
+      "import": "./dist/src/public/tools/load-skill.js",
+      "default": "./dist/src/public/tools/load-skill.js"
+    },
+    "./tools/glob": {
+      "types": "./dist/src/public/tools/glob.d.ts",
+      "import": "./dist/src/public/tools/glob.js",
+      "default": "./dist/src/public/tools/glob.js"
+    },
+    "./tools/grep": {
+      "types": "./dist/src/public/tools/grep.d.ts",
+      "import": "./dist/src/public/tools/grep.js",
+      "default": "./dist/src/public/tools/grep.js"
+    },
+    "./tools/workflow": {
+      "types": "./dist/src/public/tools/workflow.d.ts",
+      "import": "./dist/src/public/tools/workflow.js",
+      "default": "./dist/src/public/tools/workflow.js"
     },
     "./models/openai": {
       "types": "./dist/src/public/models/openai/index.d.ts",
@@ -196,6 +241,11 @@
       "import": "./dist/src/public/context/index.js",
       "default": "./dist/src/public/context/index.js"
     },
+    "./internal/programmatic-source-loader": {
+      "types": "./dist/src/internal/programmatic-source-loader.d.ts",
+      "import": "./dist/src/internal/programmatic-source-loader.js",
+      "default": "./dist/src/internal/programmatic-source-loader.js"
+    },
     "./extension": {
       "types": "./dist/src/public/extension/index.d.ts",
       "import": "./dist/src/public/extension/index.js",

package/dist/src/compiler/normalize-extension.d.ts

@@ -1,80 +0,0 @@
-import { type AgentSourceManifest, type LocalSubagentSourceRef, type ResolvedExtensionMount } from "#discover/manifest.js";
-import type { CompiledChannelEntry, CompiledConnectionDefinition, CompiledDynamicInstructionsDefinition, CompiledDynamicSkillDefinition, CompiledDynamicToolDefinition, CompiledHookDefinition, CompiledInstructionsDefinition, CompiledScheduleDefinition, CompiledSkillDefinition, CompiledToolDefinition } from "#compiler/manifest.js";
-import type { ManifestCompileContext } from "#compiler/normalize-helpers.js";
-/**
- * Contributions one mounted extension composes into the consuming agent,
- * already namespaced by the mount and rebased onto the consumer's agent root.
- */
-export interface CompiledExtensionContributions {
-    readonly channels: CompiledChannelEntry[];
-    readonly tools: CompiledToolDefinition[];
-    readonly dynamicTools: CompiledDynamicToolDefinition[];
-    readonly hooks: CompiledHookDefinition[];
-    readonly skills: CompiledSkillDefinition[];
-    readonly dynamicSkills: CompiledDynamicSkillDefinition[];
-    readonly dynamicInstructions: CompiledDynamicInstructionsDefinition[];
-    readonly connections: CompiledConnectionDefinition[];
-    readonly instructions: CompiledInstructionsDefinition[];
-    readonly schedules: CompiledScheduleDefinition[];
-}
-/**
- * Compiles one mounted extension's source tree and namespaces its
- * contributions by the mount name. Module-backed contributions keep loading
- * from the extension package because their `logicalPath` is rebased to a
- * consumer-relative path — the module-map codegen resolves it against the
- * consumer's agent root, reaching into the extension package unchanged.
- *
- * When the mount was authored as a directory (`extensions/<ns>/`), any
- * consumer-authored override slots are composed under the same namespace and
- * win on name collision: an override tool `<ns>__search` shadows the
- * extension's own `<ns>__search`.
- */
-export declare function compileExtensionContributions(input: {
-    readonly mount: ResolvedExtensionMount;
-    readonly context: ManifestCompileContext;
-    readonly consumerAgentRoot: string;
-    readonly externalDependencies: readonly string[];
-}): Promise<CompiledExtensionContributions>;
-/** Composes one mount's root-visible subagents under its namespace. */
-export declare function composeExtensionSubagentSources(input: {
-    readonly consumerAgentRoot: string;
-    readonly mount: ResolvedExtensionMount;
-}): LocalSubagentSourceRef[];
-/** Returns authored and mounted-extension subagents visible from one agent node. */
-export declare function composeAgentSubagentSources(manifest: AgentSourceManifest): LocalSubagentSourceRef[];
-/** Earlier entries win, matching directory-override precedence for other slots. */
-export declare function mergeExtensionSubagentSources(primary: readonly LocalSubagentSourceRef[], secondary: readonly LocalSubagentSourceRef[]): LocalSubagentSourceRef[];
-export interface DisabledToolTarget {
-    /** Namespaced target, e.g. `crm__search`. */
-    readonly name: string;
-    /** Override-relative authored path, e.g. `tools/search.ts`, for diagnostics. */
-    readonly logicalPath: string;
-}
-/**
- * Removes the extension tools an override slot opted out of with `disableTool()`.
- * A `disableTool()` targets a slot by name, so it removes the extension's
- * same-named static tool or dynamic resolver — whichever kind occupies the slot.
- * A disable that matches neither throws rather than silently disabling nothing.
- *
- * Exported for unit testing.
- */
-export declare function applyOverrideDisables(input: {
-    readonly merged: CompiledExtensionContributions;
-    readonly disables: readonly DisabledToolTarget[];
-    readonly extensionToolNames: ReadonlySet<string>;
-    readonly extensionDynamicToolSlugs: ReadonlySet<string>;
-    readonly namespace: string;
-}): CompiledExtensionContributions;
-/**
- * Merges two composed contribution sets with earlier-set-wins precedence per
- * composed name. Named contributions dedup by their composed identifier so
- * an override shadows the extension's same-named entry. Channel entries dedup
- * as a group so every route from the winning channel is preserved. Unnamed
- * contributions (hooks, dynamic skills, dynamic instructions, static
- * instructions) simply concatenate.
- *
- * Exported for unit testing: passing the consumer overrides as `primary` and
- * the extension's own contributions as `secondary` yields consumer-wins
- * shadowing on name collision.
- */
-export declare function mergeContributions(primary: CompiledExtensionContributions, secondary: CompiledExtensionContributions): CompiledExtensionContributions;

package/dist/src/compiler/normalize-extension.js

@@ -1 +0,0 @@
-import{join,relative}from"node:path";import{compileChannelDefinition}from"#compiler/normalize-channel.js";import{createPathDerivedSourceId}from"#discover/manifest.js";import{compileConnectionDefinition}from"#compiler/normalize-connection.js";import{compileHookEntry}from"#compiler/normalize-hook.js";import{compileInstructionsEntry}from"#compiler/normalize-instructions.js";import{compileScheduleDefinition}from"#compiler/normalize-schedule.js";import{compileSkillSource}from"#compiler/normalize-skill.js";import{compileToolEntry}from"#compiler/normalize-tool.js";async function compileExtensionContributions(e){let{mount:t,consumerAgentRoot:n}=e,r={externalDependencies:e.externalDependencies},i=await composeManifestContributions({manifest:t.manifest,namespace:t.namespace,consumerAgentRoot:n,options:r,sourceIdScope:`ext:${t.namespace}`,role:`extension`});if(t.overrides===void 0)return i.contributions;let a=await composeManifestContributions({manifest:t.overrides,namespace:t.namespace,consumerAgentRoot:n,options:r,sourceIdScope:`ext-override:${t.namespace}`,role:`override`});return applyOverrideDisables({merged:mergeContributions(a.contributions,i.contributions),disables:a.disabledToolTargets,extensionToolNames:new Set(i.contributions.tools.map(e=>e.name)),extensionDynamicToolSlugs:new Set(i.contributions.dynamicTools.map(e=>e.slug)),namespace:t.namespace})}function composeExtensionSubagentSources(e){let t=scopeExtensionSubagents({consumerAgentRoot:e.consumerAgentRoot,manifest:e.mount.manifest,namespace:e.mount.namespace,sourceIdScope:`ext:${e.mount.namespace}`,sourceRoot:e.mount.sourceRoot});return e.mount.overrides===void 0?t:mergeExtensionSubagentSources(scopeExtensionSubagents({consumerAgentRoot:e.consumerAgentRoot,manifest:e.mount.overrides,namespace:e.mount.namespace,sourceIdScope:`ext-override:${e.mount.namespace}`,sourceRoot:e.mount.overrides.agentRoot}),t)}function composeAgentSubagentSources(e){return[...e.subagents,...[...e.resolvedExtensions].sort((e,t)=>e.namespace.localeCompare(t.namespace)).flatMap(t=>composeExtensionSubagentSources({consumerAgentRoot:e.agentRoot,mount:t}))]}function mergeExtensionSubagentSources(e,t){return dedupeBy([...e,...t],e=>e.subagentId)}function scopeExtensionSubagents(e){return e.manifest.subagents.map(n=>({...scopeExtensionSubagentSource(n,e.sourceRoot,e.sourceIdScope),logicalPath:relative(e.consumerAgentRoot,n.entryPath).replaceAll(`\\`,`/`),subagentId:`${e.namespace}__${n.subagentId}`}))}function scopeExtensionSubagentSource(e,t,n){return{...e,manifest:scopeExtensionSubagentManifest(e.manifest,t,n),sourceId:scopeExtensionSourceId(t,e.entryPath,n)}}function scopeExtensionSubagentManifest(t,n,r){let scopeRef=i=>({...i,sourceId:scopeExtensionSourceId(n,join(t.agentRoot,i.logicalPath),r)});return{...t,channels:t.channels.map(scopeRef),connections:t.connections.map(scopeRef),...t.configModule===void 0?{}:{configModule:scopeRef(t.configModule)},extensions:t.extensions.map(scopeRef),hooks:t.hooks.map(scopeRef),instructions:t.instructions.map(scopeRef),lib:t.lib.map(scopeRef),sandbox:t.sandbox===null?null:scopeRef(t.sandbox),sandboxWorkspaces:t.sandboxWorkspaces.map(scopeRef),schedules:t.schedules.map(scopeRef),skills:t.skills.map(scopeRef),subagents:t.subagents.map(e=>scopeExtensionSubagentSource(e,n,r)),tools:t.tools.map(scopeRef)}}function scopeExtensionSourceId(e,n,i){return`${i}:${createPathDerivedSourceId(relative(e,n).replaceAll(`\\`,`/`))}`}function applyOverrideDisables(e){if(e.disables.length===0)return e.merged;let t=e.namespace.length+2,n=new Set;for(let r of e.disables){if(!e.extensionToolNames.has(r.name)&&!e.extensionDynamicToolSlugs.has(r.name)){let n=[...e.extensionToolNames,...e.extensionDynamicToolSlugs].map(e=>e.slice(t)).sort();throw Error(`The override "agent/extensions/${e.namespace}/${r.logicalPath}" calls disableTool(), but the "${e.namespace}" extension contributes no tool named "${r.name.slice(t)}". It contributes: ${n.length>0?n.join(`, `):`(no tools)`}.`)}n.add(r.name)}return{...e.merged,tools:e.merged.tools.filter(e=>!n.has(e.name)),dynamicTools:e.merged.dynamicTools.filter(e=>!n.has(e.slug))}}async function composeManifestContributions(r){let{manifest:o,namespace:s,consumerAgentRoot:c,options:l,sourceIdScope:u,role:d}=r,f=o.agentRoot,p=`${s}__`,scopeSourceId=e=>`${u}:${e}`,rebase=n=>relative(c,join(f,n)).replaceAll(`\\`,`/`),m=(await Promise.all(o.channels.map(e=>compileChannelDefinition(f,e,l)))).flat().map(e=>e.kind===`disabled`?{...e,name:`${p}${e.name}`,logicalPath:rebase(e.logicalPath)}:{...e,name:`${p}${e.name}`,sourceId:scopeSourceId(e.sourceId),logicalPath:rebase(e.logicalPath)}),h=[],g=[],_=[];for(let e of o.tools){let t=await compileToolEntry(f,e,l);if(t.kind===`tool`)h.push({...t.definition,name:`${p}${t.definition.name}`,sourceId:scopeSourceId(t.definition.sourceId),logicalPath:rebase(t.definition.logicalPath)});else if(t.kind===`dynamic-tool`)g.push({...t.definition,slug:`${p}${t.definition.slug}`,extensionNamespace:s,sourceId:scopeSourceId(t.definition.sourceId),logicalPath:rebase(t.definition.logicalPath)});else if(t.kind===`workflow-tool`)throw Error(`${describeExtensionSource(d,s,e.logicalPath)} enables the Workflow tool, but the Workflow tool is the consuming agent's to enable, not an extension's. Remove it.`);else if(t.kind===`web-search-tool`)throw Error(`${describeExtensionSource(d,s,e.logicalPath)} configures web search, but the web search provider is the consuming agent's to configure, not an extension's. Remove it.`);else if(d===`extension`)throw Error(`${describeExtensionSource(d,s,e.logicalPath)} calls disableTool(), but an extension cannot disable framework tools — that is the consuming agent's to own. Remove it.`);else _.push({name:`${p}${t.name}`,logicalPath:e.logicalPath})}let v=o.hooks.map(e=>{let t=compileHookEntry(e);return{...t,slug:`${p}${t.slug}`,sourceId:scopeSourceId(t.sourceId),logicalPath:rebase(t.logicalPath)}}),y=[],b=[];for(let e of o.skills){let t=await compileSkillSource(f,e,l);t.kind===`skill`?y.push({...t.definition,name:`${p}${t.definition.name}`,sourceId:scopeSourceId(t.definition.sourceId),logicalPath:rebase(t.definition.logicalPath)}):b.push({...t.definition,slug:`${p}${t.definition.slug}`,extensionNamespace:s,sourceId:scopeSourceId(t.definition.sourceId),logicalPath:rebase(t.definition.logicalPath)})}let x=(await Promise.all(o.connections.map(e=>compileConnectionDefinition(f,e,l)))).map(e=>({...e,connectionName:`${p}${e.connectionName}`,sourceId:scopeSourceId(e.sourceId),logicalPath:rebase(e.logicalPath)})),S=[],C=[];for(let e of o.instructions){let t=await compileInstructionsEntry(f,e,l);t.kind===`instructions`?C.push({...t.definition,sourceId:scopeSourceId(t.definition.sourceId),logicalPath:rebase(t.definition.logicalPath)}):S.push({...t.definition,slug:`${p}${t.definition.slug}`,sourceId:scopeSourceId(t.definition.sourceId),logicalPath:rebase(t.definition.logicalPath)})}return{contributions:{channels:m,tools:h,dynamicTools:g,hooks:v,skills:y,dynamicSkills:b,dynamicInstructions:S,connections:x,instructions:C,schedules:await Promise.all(o.schedules.map(async e=>{let t=await compileScheduleDefinition(f,e,l);return{...t,name:`${p}${t.name}`,sourceId:scopeSourceId(t.sourceId),logicalPath:rebase(t.logicalPath)}}))},disabledToolTargets:_}}function describeExtensionSource(e,t,n){return e===`override`?`The override "agent/extensions/${t}/${n}"`:`The "${t}" extension's "${n}"`}function mergeContributions(e,t){let n=new Set(e.channels.map(e=>e.name));return{channels:[...e.channels,...t.channels.filter(e=>!n.has(e.name))],tools:dedupeBy([...e.tools,...t.tools],e=>e.name),dynamicTools:dedupeBy([...e.dynamicTools,...t.dynamicTools],e=>e.slug),connections:dedupeBy([...e.connections,...t.connections],e=>e.connectionName),skills:dedupeBy([...e.skills,...t.skills],e=>e.name),schedules:dedupeBy([...e.schedules,...t.schedules],e=>e.name),hooks:[...e.hooks,...t.hooks],dynamicSkills:[...e.dynamicSkills,...t.dynamicSkills],dynamicInstructions:[...e.dynamicInstructions,...t.dynamicInstructions],instructions:[...e.instructions,...t.instructions]}}function dedupeBy(e,t){let n=new Set,r=[];for(let i of e){let e=t(i);n.has(e)||(n.add(e),r.push(i))}return r}export{applyOverrideDisables,compileExtensionContributions,composeAgentSubagentSources,composeExtensionSubagentSources,mergeContributions,mergeExtensionSubagentSources};

package/dist/src/execution/sandbox/write-file-tool.js

@@ -1 +0,0 @@
-import{loadContext}from"#context/container.js";import{ReadFileStateKey,buildReadFileTargetKey,createReadFileStamp,normalizeModelPath,setReadFileStamp}from"#runtime/framework-tools/file-state.js";import{resolveAbsoluteFilePath}from"#execution/sandbox/require-sandbox.js";async function executeWriteFileOnSandbox(e,t){let{filePath:n,content:r}=t,i=await resolveAbsoluteFilePath(e,n),a=loadContext(),o=normalizeModelPath(i),s=buildReadFileTargetKey(o),c=await e.readTextFile({path:i});if(c===null)return await e.writeTextFile({content:r,path:i}),setReadFileStamp(a,s,createReadFileStamp({content:r,filePath:o})),{existed:!1,path:o};let l=a.ensure(ReadFileStateKey,()=>({byTarget:{}})).byTarget[s];if(l===void 0)throw Error(`You must read file ${n} before overwriting it. Use the read_file tool first.`);let u=createReadFileStamp({content:c,filePath:o});if(u.contentHash!==l.contentHash||u.byteLength!==l.byteLength)throw Error(`File ${n} has been modified since it was last read. Please read the file again before modifying it.`);return await e.writeTextFile({content:r,path:i}),setReadFileStamp(a,s,createReadFileStamp({content:r,filePath:o})),{existed:!0,path:o}}export{executeWriteFileOnSandbox};

package/dist/src/internal/nitro/routes/agent-info/build-agent-info-response-from-manifest.d.ts

@@ -1,9 +0,0 @@
-import type { AgentInfoManifestData } from "#internal/nitro/routes/agent-info/load-agent-info-data.js";
-import type { AgentInfoResponse } from "#internal/nitro/routes/agent-info/build-agent-info-response.js";
-import { type GatewayCredentialPresence } from "#internal/resolve-model-endpoint-status.js";
-import type { ChatGptAuthState } from "#public/models/openai/chatgpt/token-broker.js";
-export declare function buildAgentInfoResponseFromManifest(data: AgentInfoManifestData, input: {
-    readonly mode: AgentInfoResponse["mode"];
-    readonly gatewayCredentials: GatewayCredentialPresence;
-    readonly chatgptAuth?: ChatGptAuthState;
-}): AgentInfoResponse;

package/dist/src/internal/nitro/routes/agent-info/build-agent-info-response-from-manifest.js

@@ -1 +0,0 @@
-import{resolveModelEndpointStatus}from"#internal/resolve-model-endpoint-status.js";import{LOAD_SKILL_TOOL_NAME}from"#runtime/skills/fragment-context.js";import{WORKFLOW_TOOL_NAME}from"#shared/workflow-sandbox.js";import{getAllFrameworkChannelNames,getFrameworkChannelDefinitions}from"#runtime/framework-channels/index.js";import{getAllFrameworkToolNames,getFrameworkDynamicToolResolvers}from"#runtime/framework-tools/index.js";import{buildFrameworkToolInfo,getRootDelegationToolNames,renderChannel,renderDynamicResolver,renderSchedule,renderSubagent,toSource}from"#internal/nitro/routes/agent-info/build-agent-info-response.js";function toChatGptEndpoint(e){if(e!==void 0)return{state:e.kind,...e.kind===`ready`&&e.accountLabel!==void 0&&{accountLabel:e.accountLabel}}}function buildAgentInfoResponseFromManifest(i,a){let o=i.manifest,s=o.channels.filter(e=>e.kind===`channel`),c=o.channels.filter(e=>e.kind===`disabled`).map(e=>e.name),l=new Set(o.tools.map(e=>e.name)),u=new Set(o.disabledFrameworkTools),d=getAllFrameworkToolNames(),f=getAllFrameworkChannelNames(),p=getFrameworkChannelDefinitions(),m=o.tools.map(e=>({...toSource(e),description:e.description,hasAuth:!1,hasCompactionHook:!1,hasExecute:!0,hasModelOutputProjection:!1,hasOutputSchema:e.outputSchema!==void 0&&e.outputSchema!==null,inputSchema:e.inputSchema,name:e.name,origin:`authored`,outputSchema:e.outputSchema??null,replacesFrameworkTool:d.has(e.name),requiresApproval:!1})),h=new Set(s.map(e=>e.name)),g=new Set(c),_=p.filter(e=>!h.has(e.name)&&!g.has(e.name)),v=buildFrameworkToolInfo({authoredToolNames:l,delegationToolNames:getRootDelegationToolNames(o),disabledFrameworkToolNames:u}),y=s.map(e=>({...toSource(e),adapterKind:e.adapterKind,method:e.method,name:e.name,origin:`authored`,urlPath:e.urlPath}));return{agent:{agentRoot:o.agentRoot,appRoot:o.appRoot,configSource:o.config.source?toSource(o.config.source):void 0,description:o.config.description,model:o.config.dynamicModel===void 0?{contextWindowTokens:o.config.model.contextWindowTokens,id:o.config.model.id,providerOptions:o.config.model.providerOptions,reasoning:o.config.reasoning,source:o.config.model.source?toSource(o.config.model.source):void 0,routing:o.config.model.routing,endpoint:resolveModelEndpointStatus(o.config.model.routing,a.gatewayCredentials,toChatGptEndpoint(a.chatgptAuth))}:{reasoning:o.config.reasoning,routing:{kind:`dynamic`}},name:o.config.name,outputSchema:o.config.outputSchema},capabilities:{devRoutes:a.mode===`development`},channels:{authored:y,available:[..._.map(e=>renderChannel(e,{origin:`framework`})),...y],disabledFramework:c,framework:p.filter(e=>f.has(e.name)).map(e=>{let t=h.has(e.name),n=g.has(e.name),r=n?`disabled`:t?`replaced`:`active`;return{...renderChannel(e,{origin:`framework`}),disabledByAuthor:n,replacedByAuthoredChannel:t,status:r}})},connections:o.connections.map(e=>({...toSource(e),connectionName:e.connectionName,description:e.description,hasApproval:!1,hasAuthorization:e.vercelConnect!==void 0,hasHeaders:!1,protocol:e.protocol,url:e.url})),diagnostics:{discoveryErrors:o.diagnosticsSummary.errors,discoveryWarnings:o.diagnosticsSummary.warnings},hooks:o.hooks.map(e=>({...toSource(e),eventNames:[],slug:e.slug})),instructions:{dynamic:o.dynamicInstructions.map(e=>renderDynamicResolver(e,{origin:`authored`})),static:o.instructions.map(e=>({...toSource(e),content:e.content,name:e.name,role:e.role}))},kind:`eve-agent-info`,mode:a.mode,sandbox:o.sandbox===null?null:{...toSource(o.sandbox),description:o.sandbox.description,hasBootstrap:!1,hasOnSession:!1,revalidationKey:o.sandbox.revalidationKey,sourceHash:o.sandbox.sourceHash},schedules:i.schedules.map(renderSchedule),skills:{static:o.skills.map(e=>({...toSource(e),description:e.description,license:e.license,markdown:e.markdown,metadata:e.metadata,name:e.name})),dynamic:o.dynamicSkills.map(e=>renderDynamicResolver(e,{origin:`authored`}))},subagents:{local:o.subagents.map(renderSubagent),total:o.subagents.length},tools:{available:[...v.available,...m],authored:m,disabledFramework:[...o.disabledFrameworkTools],dynamic:[...getFrameworkDynamicToolResolvers().map(e=>renderDynamicResolver(e,{origin:`framework`})),...o.dynamicTools.map(e=>renderDynamicResolver(e,{origin:`authored`}))],framework:v.framework,reserved:[WORKFLOW_TOOL_NAME,LOAD_SKILL_TOOL_NAME]},version:2,workflow:{enabled:o.workflowTool!==void 0,toolName:WORKFLOW_TOOL_NAME},workspace:{resourceRoot:o.workspaceResourceRoot,rootEntries:[...o.workspaceResourceRoot.rootEntries]}}}export{buildAgentInfoResponseFromManifest};

package/dist/src/internal/nitro/routes/health.d.ts

@@ -1,14 +0,0 @@
-import type { H3Event } from "nitro";
-export default _default;
-/**
- * Nitro route for eve's health endpoint.
- *
- * The health endpoint is intentionally always-public so platform load
- * balancers and uptime monitors can probe it without credentials.
- * Channels that need authenticated health probes should author their own
- * channel file with the verifier helpers from
- * `eve/channels/auth`.
- */
-declare function _default(_event: H3Event<{
-    body: unknown;
-}>): Promise<Response>;

package/dist/src/internal/nitro/routes/health.js

@@ -1 +0,0 @@
-import{workflowEntryReference}from"#execution/workflow-runtime.js";var health_default=async e=>Response.json({ok:!0,status:`ready`,workflowId:workflowEntryReference.workflowId});export{health_default as default};

package/dist/src/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js

@@ -1 +0,0 @@
-import{__commonJSMin}from"../../../../../_virtual/_rolldown/runtime.js";var require_picocolors=__commonJSMin(((e,t)=>{let n=process||{},r=n.argv||[],i=n.env||{},a=!(i.NO_COLOR||r.includes(`--no-color`))&&(!!i.FORCE_COLOR||r.includes(`--color`)||n.platform===`win32`||(n.stdout||{}).isTTY&&i.TERM!==`dumb`||!!i.CI),formatter=(e,t,n=e)=>r=>{let i=``+r,a=i.indexOf(t,e.length);return~a?e+replaceClose(i,t,n,a)+t:e+i+t},replaceClose=(e,t,n,r)=>{let i=``,a=0;do i+=e.substring(a,r)+n,a=r+t.length,r=e.indexOf(t,a);while(~r);return i+e.substring(a)},createColors=(e=a)=>{let t=e?formatter:()=>String;return{isColorSupported:e,reset:t(`\x1B[0m`,`\x1B[0m`),bold:t(`\x1B[1m`,`\x1B[22m`,`\x1B[22m\x1B[1m`),dim:t(`\x1B[2m`,`\x1B[22m`,`\x1B[22m\x1B[2m`),italic:t(`\x1B[3m`,`\x1B[23m`),underline:t(`\x1B[4m`,`\x1B[24m`),inverse:t(`\x1B[7m`,`\x1B[27m`),hidden:t(`\x1B[8m`,`\x1B[28m`),strikethrough:t(`\x1B[9m`,`\x1B[29m`),black:t(`\x1B[30m`,`\x1B[39m`),red:t(`\x1B[31m`,`\x1B[39m`),green:t(`\x1B[32m`,`\x1B[39m`),yellow:t(`\x1B[33m`,`\x1B[39m`),blue:t(`\x1B[34m`,`\x1B[39m`),magenta:t(`\x1B[35m`,`\x1B[39m`),cyan:t(`\x1B[36m`,`\x1B[39m`),white:t(`\x1B[37m`,`\x1B[39m`),gray:t(`\x1B[90m`,`\x1B[39m`),bgBlack:t(`\x1B[40m`,`\x1B[49m`),bgRed:t(`\x1B[41m`,`\x1B[49m`),bgGreen:t(`\x1B[42m`,`\x1B[49m`),bgYellow:t(`\x1B[43m`,`\x1B[49m`),bgBlue:t(`\x1B[44m`,`\x1B[49m`),bgMagenta:t(`\x1B[45m`,`\x1B[49m`),bgCyan:t(`\x1B[46m`,`\x1B[49m`),bgWhite:t(`\x1B[47m`,`\x1B[49m`),blackBright:t(`\x1B[90m`,`\x1B[39m`),redBright:t(`\x1B[91m`,`\x1B[39m`),greenBright:t(`\x1B[92m`,`\x1B[39m`),yellowBright:t(`\x1B[93m`,`\x1B[39m`),blueBright:t(`\x1B[94m`,`\x1B[39m`),magentaBright:t(`\x1B[95m`,`\x1B[39m`),cyanBright:t(`\x1B[96m`,`\x1B[39m`),whiteBright:t(`\x1B[97m`,`\x1B[39m`),bgBlackBright:t(`\x1B[100m`,`\x1B[49m`),bgRedBright:t(`\x1B[101m`,`\x1B[49m`),bgGreenBright:t(`\x1B[102m`,`\x1B[49m`),bgYellowBright:t(`\x1B[103m`,`\x1B[49m`),bgBlueBright:t(`\x1B[104m`,`\x1B[49m`),bgMagentaBright:t(`\x1B[105m`,`\x1B[49m`),bgCyanBright:t(`\x1B[106m`,`\x1B[49m`),bgWhiteBright:t(`\x1B[107m`,`\x1B[49m`)}};t.exports=createColors(),t.exports.createColors=createColors}));export default require_picocolors();export{require_picocolors};

package/dist/src/public/definitions/tool.js

@@ -1 +0,0 @@
-import{DYNAMIC_SENTINEL_KIND,TOOL_BRAND}from"#shared/dynamic-tool-definition.js";import{collectDurableDynamicToolCallbacks,stampDurableDynamicToolCallbacks}from"#shared/durable-dynamic-tool-callbacks.js";import{stampDefinitionKey}from"#public/tool-result-narrowing.js";function defineTool(e){if(e.auth!==void 0)throw Error(`defineTool: The "auth" field is no longer supported. Pass auth providers inline to ctx.getToken(provider) or ctx.requireAuth(provider).`);return Object.assign(e,{[TOOL_BRAND]:!0}),stampDurableDynamicToolCallbacks(e,collectDurableDynamicToolCallbacks({approval:e.approval,execute:e.execute,toModelOutput:e.toModelOutput})),stampDefinitionKey(e,`tool:${e.description}`),e}function defineDynamic(t){let n={kind:DYNAMIC_SENTINEL_KIND,events:t.events};return stampDefinitionKey(n,`dynamic:${Object.keys(t.events).join(`,`)}`),n}const DISABLED_TOOL_SENTINEL_KIND=`eve:disabled-tool`;function disableTool(){return{kind:DISABLED_TOOL_SENTINEL_KIND}}function isDisabledToolSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_TOOL_SENTINEL_KIND}const EXPERIMENTAL_WORKFLOW_TOOL_KIND=`eve:enable-workflow-tool`;function experimental_workflow(e={}){let t={kind:EXPERIMENTAL_WORKFLOW_TOOL_KIND};return e.maxSubagents!==void 0&&(t.maxSubagents=e.maxSubagents),t}function isExperimentalWorkflowToolDefinition(e){return typeof e==`object`&&!!e&&e.kind===EXPERIMENTAL_WORKFLOW_TOOL_KIND}export{defineDynamic,defineTool,disableTool,experimental_workflow,isDisabledToolSentinel,isExperimentalWorkflowToolDefinition};

package/dist/src/public/tool-result-narrowing.js

@@ -1 +0,0 @@
-const DEFINITION_KEY=Symbol.for(`eve.definition-source-key`),REGISTRY_SYMBOL=Symbol.for(`eve.definition-source-registry`),registryContainer=globalThis;registryContainer[REGISTRY_SYMBOL]===void 0&&(registryContainer[REGISTRY_SYMBOL]=new Map);const definitionSourceRegistry=registryContainer[REGISTRY_SYMBOL];function stampDefinitionKey(t,n){Object.defineProperty(t,DEFINITION_KEY,{configurable:!0,value:n})}function readDefinitionKey(t){if(DEFINITION_KEY in t)return t[DEFINITION_KEY]}function registerDefinitionSource(e,t){let n=definitionSourceRegistry.get(e);if(n!==void 0&&!sameDefinitionSourceEntry(n,t)){n.kind!==`ambiguous`&&console.warn([`eve could not assign a unique toolResultFrom identity for ${JSON.stringify(e)}.`,`Conflicting definitions: ${formatDefinitionSourceForWarning(n)} and ${formatDefinitionSourceForWarning(t)}.`,`Multiple authored definitions share that fallback identity, so toolResultFrom will not match through it.`,`Use the original definition object loaded by eve so source-derived identity can be used instead.`].join(` `)),definitionSourceRegistry.set(e,{kind:`ambiguous`});return}definitionSourceRegistry.set(e,t)}function sameDefinitionSourceEntry(e,t){return e.kind===t.kind&&e.name===t.name}function formatDefinitionSourceForWarning(e){return e.logicalPath===void 0?`${e.kind} "${e.name}"`:`${e.kind} "${e.name}" from "${e.logicalPath}"`}const toolResultFrom=toolResultFromImpl;function toolResultFromImpl(e,t){if(e.kind!==`tool-result`||e.isError===!0)return;let n=readDefinitionKey(t);if(n===void 0)return;let r=definitionSourceRegistry.get(n);if(r===void 0||r.kind===`ambiguous`)return;if(r.kind===`tool`)return e.toolName===r.name?{callId:e.callId,output:e.output,toolName:e.toolName}:void 0;let i=r.name+`__`;if(e.toolName.startsWith(i))return{callId:e.callId,connectionToolName:e.toolName.slice(i.length),output:e.output,toolName:e.toolName}}export{registerDefinitionSource,stampDefinitionKey,toolResultFrom};

package/dist/src/public/tools/approval/approval-helpers.js

@@ -1 +0,0 @@
-import{stampDurableDynamicCallback}from"#shared/durable-dynamic-tool-callbacks.js";function alwaysApproval(e){return`user-approval`}function neverApproval(e){return`not-applicable`}function onceApproval(e,t){return t.approvedTools.has(t.toolName)?`not-applicable`:`user-approval`}function always(){return stampDurableDynamicCallback(()=>`user-approval`,{callback:alwaysApproval,closure:{}})}function never(){return stampDurableDynamicCallback(()=>`not-applicable`,{callback:neverApproval,closure:{}})}function once(){return stampDurableDynamicCallback(({approvedTools:e,toolName:t})=>e.has(t)?`not-applicable`:`user-approval`,{callback:onceApproval,closure:{}})}export{always,never,once};

package/dist/src/public/tools/defaults.d.ts

@@ -1,46 +0,0 @@
-import type { ToolDefinition } from "#public/definitions/tool.js";
-export type { ToolDefinition };
-/**
- * Framework-provided shell execution tool. Spread or wrap to customize.
- */
-export declare const bash: ToolDefinition;
-/**
- * Framework-provided file search tool. Finds files by glob pattern. Spread
- * or wrap to customize.
- */
-export declare const glob: ToolDefinition;
-/**
- * Framework-provided content search tool. Searches file contents by regex
- * pattern. Spread or wrap to customize.
- */
-export declare const grep: ToolDefinition;
-/**
- * Framework-provided file reader tool (`read_file`). Spread or wrap to
- * customize. The framework resets the durable read-before-write stamps on
- * context compaction automatically, regardless of how the reader is defined.
- */
-export declare const readFile: ToolDefinition;
-/**
- * Framework-provided file writer tool. Spread or wrap to customize.
- * Enforces read-before-write for existing files and stale-read detection.
- */
-export declare const writeFile: ToolDefinition;
-/**
- * Framework-provided HTTP fetch tool. Spread or wrap to customize.
- */
-export declare const webFetch: ToolDefinition;
-/**
- * Framework-provided durable todo list tool. Spreading the default keeps its
- * closure-bound state behavior: the executor still reads and writes the
- * framework's internal todo state. Replace with a fully custom executor (and
- * your own `ContextKey`) if you need different state semantics.
- */
-export declare const todo: ToolDefinition;
-/**
- * Framework-provided skill loading tool (`load_skill`). Returns a named
- * authored skill's instructions directly; dynamic skills remain sandbox-backed.
- * It is only useful when the agent declares skills: with no skills available the
- * framework does not surface skill descriptions to the model, so the model has
- * nothing to load.
- */
-export declare const loadSkill: ToolDefinition;

package/dist/src/public/tools/defaults.js

@@ -1 +0,0 @@
-import{TODO_TOOL_DEFINITION}from"#runtime/framework-tools/todo.js";import{BASH_TOOL_DEFINITION}from"#runtime/framework-tools/bash.js";import{GLOB_TOOL_DEFINITION}from"#runtime/framework-tools/glob.js";import{GREP_TOOL_DEFINITION}from"#runtime/framework-tools/grep.js";import{READ_FILE_TOOL_DEFINITION}from"#runtime/framework-tools/read-file.js";import{SKILL_TOOL_DEFINITION}from"#runtime/framework-tools/skill.js";import{WEB_FETCH_TOOL_DEFINITION}from"#runtime/framework-tools/web-fetch.js";import{WRITE_FILE_TOOL_DEFINITION}from"#runtime/framework-tools/write-file.js";import{toPublicToolDefinition}from"#public/tools/internal.js";const bash=toPublicToolDefinition(BASH_TOOL_DEFINITION),glob=toPublicToolDefinition(GLOB_TOOL_DEFINITION),grep=toPublicToolDefinition(GREP_TOOL_DEFINITION),readFile=toPublicToolDefinition(READ_FILE_TOOL_DEFINITION),writeFile=toPublicToolDefinition(WRITE_FILE_TOOL_DEFINITION),webFetch=toPublicToolDefinition(WEB_FETCH_TOOL_DEFINITION),todo=toPublicToolDefinition(TODO_TOOL_DEFINITION),loadSkill=toPublicToolDefinition(SKILL_TOOL_DEFINITION);export{bash,glob,grep,loadSkill,readFile,todo,webFetch,writeFile};

package/dist/src/public/tools/define-bash-tool.d.ts

@@ -1,21 +0,0 @@
-import type { ToolDefinition } from "#public/definitions/tool.js";
-/**
- * Input shape accepted by {@link defineBashTool}.
- */
-export interface DefineBashToolInput {
-    /**
-     * Optional model-facing description. Defaults to a generic
-     * "Execute a shell command in the workspace sandbox." line.
-     */
-    readonly description?: string;
-}
-/**
- * Defines a model-visible shell-runner tool that executes commands
- * inside the agent's sandbox. Uses the same executor core as the
- * framework `bash` tool, so input schema, error messages, and result
- * shape are identical.
- *
- * The tool's runtime name comes from the authored file's slug (for
- * example `agent/tools/run_shell.ts` becomes a tool named `run_shell`).
- */
-export declare function defineBashTool(input?: DefineBashToolInput): ToolDefinition;

package/dist/src/public/tools/define-bash-tool.js

@@ -1 +0,0 @@
-import{BASH_INPUT_SCHEMA,BASH_OUTPUT_SCHEMA}from"#runtime/framework-tools/bash.js";import{executeBashOnSandbox}from"#execution/sandbox/bash-tool.js";function defineBashTool(n={}){return{description:n.description??`Execute a shell command in the workspace sandbox.`,async execute(e,t){return executeBashOnSandbox(await t.getSandbox(),e)},inputSchema:BASH_INPUT_SCHEMA,outputSchema:BASH_OUTPUT_SCHEMA}}export{defineBashTool};

package/dist/src/public/tools/define-glob-tool.d.ts

@@ -1,22 +0,0 @@
-import type { ToolDefinition } from "#public/definitions/tool.js";
-/**
- * Input shape accepted by {@link defineGlobTool}.
- */
-export interface DefineGlobToolInput {
-    /**
-     * Optional model-facing description. Defaults to a generic
-     * "Search for files by glob pattern in the workspace sandbox." line.
-     */
-    readonly description?: string;
-}
-/**
- * Defines a model-visible file-search tool that discovers files by
- * glob pattern inside the agent's sandbox. Uses the same executor core
- * as the framework `glob` tool, so input schema, error messages, and
- * result shape are identical.
- *
- * The tool's runtime name comes from the authored file's slug (for
- * example `agent/tools/find_files.ts` becomes a tool named
- * `find_files`).
- */
-export declare function defineGlobTool(input?: DefineGlobToolInput): ToolDefinition;

package/dist/src/public/tools/define-glob-tool.js

@@ -1 +0,0 @@
-import{GLOB_INPUT_SCHEMA,GLOB_OUTPUT_SCHEMA}from"#runtime/framework-tools/glob.js";import{executeGlobOnSandbox}from"#execution/sandbox/glob-tool.js";function defineGlobTool(n={}){return{description:n.description??`Search for files by glob pattern in the workspace sandbox.`,async execute(e,t){return executeGlobOnSandbox(await t.getSandbox(),e)},inputSchema:GLOB_INPUT_SCHEMA,outputSchema:GLOB_OUTPUT_SCHEMA}}export{defineGlobTool};

package/dist/src/public/tools/define-grep-tool.d.ts

@@ -1,22 +0,0 @@
-import type { ToolDefinition } from "#public/definitions/tool.js";
-/**
- * Input shape accepted by {@link defineGrepTool}.
- */
-export interface DefineGrepToolInput {
-    /**
-     * Optional model-facing description. Defaults to a generic
-     * "Search file contents by pattern in the workspace sandbox." line.
-     */
-    readonly description?: string;
-}
-/**
- * Defines a model-visible content-search tool that searches file
- * contents by pattern inside the agent's sandbox. Uses the same
- * executor core as the framework `grep` tool, so input schema, error
- * messages, and result shape are identical.
- *
- * The tool's runtime name comes from the authored file's slug (for
- * example `agent/tools/search_code.ts` becomes a tool named
- * `search_code`).
- */
-export declare function defineGrepTool(input?: DefineGrepToolInput): ToolDefinition;

package/dist/src/public/tools/define-grep-tool.js

@@ -1 +0,0 @@
-import{GREP_INPUT_SCHEMA,GREP_OUTPUT_SCHEMA}from"#runtime/framework-tools/grep.js";import{executeGrepOnSandbox}from"#execution/sandbox/grep-tool.js";function defineGrepTool(n={}){return{description:n.description??`Search file contents by pattern in the workspace sandbox.`,async execute(e,t){return executeGrepOnSandbox(await t.getSandbox(),e)},inputSchema:GREP_INPUT_SCHEMA,outputSchema:GREP_OUTPUT_SCHEMA}}export{defineGrepTool};

package/dist/src/public/tools/define-read-file-tool.d.ts

@@ -1,21 +0,0 @@
-import type { ToolDefinition } from "#public/definitions/tool.js";
-/**
- * Input shape accepted by {@link defineReadFileTool}.
- */
-export interface DefineReadFileToolInput {
-    /**
-     * Optional model-facing description. Defaults to a generic
-     * "Read a file from the workspace sandbox." line.
-     */
-    readonly description?: string;
-}
-/**
- * Defines a model-visible file-reader tool that reads files from the
- * agent's sandbox. Uses the same executor core as the framework
- * `read_file` tool, so input schema, error messages, and result shape
- * are identical.
- *
- * The tool's runtime name comes from the authored file's slug (for
- * example `agent/tools/read_file.ts` becomes a tool named `read_file`).
- */
-export declare function defineReadFileTool(input?: DefineReadFileToolInput): ToolDefinition;

package/dist/src/public/tools/define-read-file-tool.js

@@ -1 +0,0 @@
-import{READ_FILE_INPUT_SCHEMA,READ_FILE_OUTPUT_SCHEMA}from"#runtime/framework-tools/read-file.js";import{executeReadFileOnSandbox}from"#execution/sandbox/read-file-tool.js";function defineReadFileTool(n={}){return{description:n.description??`Read a file from the workspace sandbox.`,async execute(e,t){return executeReadFileOnSandbox(await t.getSandbox(),e)},inputSchema:READ_FILE_INPUT_SCHEMA,outputSchema:READ_FILE_OUTPUT_SCHEMA}}export{defineReadFileTool};