eve 0.68.0 → 0.70.0

package/dist/src/tasks/json.d.ts

@@ -1,88 +0,0 @@
-import { z } from "#compiled/zod/index.js";
-import type { JsonValue } from "#shared/json.js";
-import type { TaskView } from "#tasks/types.js";
-/** Strict model-visible task projection. */
-declare const TASK_VIEW_JSON_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    status: z.ZodLiteral<"working">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    inputRequests: z.ZodReadonly<z.ZodArray<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
-    status: z.ZodLiteral<"input_required">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    lastOutput: z.ZodObject<{
-        data: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
-        type: z.ZodLiteral<"result">;
-    }, z.core.$strip>;
-    status: z.ZodLiteral<"completed">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    lastOutput: z.ZodObject<{
-        data: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
-        type: z.ZodLiteral<"error">;
-    }, z.core.$strip>;
-    status: z.ZodLiteral<"failed">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    status: z.ZodLiteral<"cancelled">;
-}, z.core.$strip>], "status">;
-/**
- * Model-visible task view, inferred from {@link TASK_VIEW_JSON_SCHEMA}.
- *
- * This is the public projection of `TaskView` (#tasks/types.js), not a
- * replacement for it: the durable view additionally carries private
- * `executor` and `usage`, and its module must stay zod-free because it is
- * bundled into workflow bodies.
- */
-type TaskViewJson = z.infer<typeof TASK_VIEW_JSON_SCHEMA>;
-/** Projects a task view into the JSON value carried by tool results. */
-export declare function taskViewToJson(view: TaskView): TaskViewJson;
-/** Projects many views into one `{ tasks }` tool output. */
-export declare function taskViewsToJson(views: readonly TaskView[]): JsonValue;
-export {};

package/dist/src/tasks/json.js

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{jsonValueSchema}from"#shared/json-schemas.js";const taskMetadataJsonSchema=z.object({agentId:z.string().optional(),kind:z.string(),mode:z.enum([`local`,`remote`]).optional(),name:z.string()}),taskOutputJsonSchema=z.object({data:jsonValueSchema,type:z.enum([`result`,`error`])}),taskViewJsonBaseShape={metadata:taskMetadataJsonSchema,taskId:z.string()},TASK_VIEW_JSON_SCHEMA=z.discriminatedUnion(`status`,[z.object({...taskViewJsonBaseShape,status:z.literal(`working`)}),z.object({...taskViewJsonBaseShape,inputRequests:z.array(jsonValueSchema).readonly(),status:z.literal(`input_required`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`result`)}),status:z.literal(`completed`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`error`)}),status:z.literal(`failed`)}),z.object({...taskViewJsonBaseShape,status:z.literal(`cancelled`)})]);function taskViewToJson(e){return TASK_VIEW_JSON_SCHEMA.parse(e)}function taskViewsToJson(e){return{tasks:e.map(e=>taskViewToJson(e))}}export{taskViewToJson,taskViewsToJson};

package/dist/src/tasks/notification.d.ts

@@ -1,10 +0,0 @@
-import type { DeliverHookPayload } from "#channel/types.js";
-import type { SessionStateMap } from "#harness/types.js";
-import type { JsonValue } from "#shared/json.js";
-import type { TaskView } from "#tasks/types.js";
-export declare function formatTaskNotification(view: TaskView): string;
-export declare function formatTaskOutput(output: JsonValue): string;
-/** Task delivery ids are `<taskId>` or `<taskId>:<event>`; derived task ids never contain `:`. */
-export declare function taskIdOfDelivery(deliveryId: string): string;
-/** The parent already recorded this task's outcome, so the delivery cannot notify the model again. */
-export declare function hasRecordedTaskOutcome(delivery: DeliverHookPayload, state: SessionStateMap | undefined): boolean;

package/dist/src/tasks/notification.js

@@ -1 +0,0 @@
-import{getBackgroundTasks}from"#harness/workflow-tool-runs.js";function formatTaskNotification(e){let t=`Background task ${e.taskId} (${e.metadata.name})`;return e.status===`input_required`?`${t} needs input.`:e.status===`completed`?`${t} is completed.\n\nResult:\n${formatTaskOutput(e.lastOutput.data)}`:e.status===`failed`?`${t} failed.\n\nError:\n${formatTaskOutput(e.lastOutput.data)}`:`${t} is cancelled.`}function formatTaskOutput(e){return typeof e==`string`?e:JSON.stringify(e)??`null`}function taskIdOfDelivery(e){let t=e.indexOf(`:`);return t<0?e:e.slice(0,t)}function hasRecordedTaskOutcome(e,t){let n=e.taskDeliveryId;if(n===void 0)return!1;let r=getBackgroundTasks(t).get(taskIdOfDelivery(n));return r!==void 0&&r.status!==`working`}export{formatTaskNotification,formatTaskOutput,hasRecordedTaskOutcome,taskIdOfDelivery};

package/dist/src/tasks/task-id.d.ts

@@ -1,31 +0,0 @@
-/**
- * Derives the stable task id for one originating background call.
- *
- * Uses `hash(parentSessionId, parentTurnId, callId)` so replayed creation
- * for the same call yields the same task, and a
- * task can never be confused with a child session id or continuation
- * token.
- *
- * Lives apart from the pure task modules because the derivation needs
- * `node:crypto`, which workflow bodies reject; ids are only ever minted
- * inside dispatch steps.
- */
-export declare function deriveTaskId(input: {
-    readonly callId: string;
-    readonly parentSessionId: string;
-    readonly parentTurnId: string;
-}): string;
-/**
- * Derives the task run's private inbox token.
- *
- * Deterministic on purpose: a durable replay of the dispatch step must
- * re-derive the same token so the duplicate task run loses the hook
- * claim and exits instead of splitting the lifecycle across two runs.
- * Unguessable in practice: the parent session's continuation token is
- * itself a private capability, and the derived token never renders to
- * the model.
- */
-export declare function deriveTaskInboxToken(input: {
-    readonly parentContinuationToken: string;
-    readonly taskId: string;
-}): string;

package/dist/src/tasks/task-id.js

@@ -1 +0,0 @@
-import{createHash}from"node:crypto";function deriveTaskId(e){return`task_${createHash(`sha256`).update(`${e.parentSessionId}\0${e.parentTurnId}\0${e.callId}`).digest(`hex`).slice(0,24)}`}function deriveTaskInboxToken(e){return`task:${e.taskId}:${createHash(`sha256`).update(`${e.taskId}\0${e.parentContinuationToken}`).digest(`hex`).slice(0,32)}`}export{deriveTaskId,deriveTaskInboxToken};

package/dist/src/tasks/task-inbox-token.d.ts

@@ -1,2 +0,0 @@
-/** Reads the non-secret task id embedded in a private task inbox token. */
-export declare function readTaskIdFromInboxToken(token: string): string | undefined;

package/dist/src/tasks/task-inbox-token.js

@@ -1 +0,0 @@
-function readTaskIdFromInboxToken(e){return/^task:(task_[^:]+):[a-f0-9]{32}$/.exec(e)?.[1]}export{readTaskIdFromInboxToken};

package/dist/src/tasks/transitions.d.ts

@@ -1,17 +0,0 @@
-import type { WorkflowToolRunOutcomeMessage } from "#execution/tools/workflow/messages.js";
-import { type TaskCommand, type TaskView } from "#tasks/types.js";
-export type TaskTransitionResult = {
-    readonly action: "accepted";
-    readonly view: TaskView;
-} | {
-    readonly action: "noop";
-    readonly view: TaskView;
-} | {
-    readonly action: "rejected";
-    readonly view: TaskView;
-    readonly reason: string;
-};
-/** Pure transition function for the background invocation view. */
-export declare function applyTaskTransition(view: TaskView, command: TaskCommand | ({
-    readonly kind: "outcome";
-} & WorkflowToolRunOutcomeMessage)): TaskTransitionResult;

package/dist/src/tasks/transitions.js

@@ -1 +0,0 @@
-import{workflowToolRunFailureOutput}from"#execution/tools/workflow/owner-inbox.js";import{isTerminalTaskStatus,readTaskInputRequestId}from"#tasks/types.js";function applyTaskTransition(e,t){if(isTerminalTaskStatus(e.status))return t.kind===`cancel`&&e.status===`cancelled`?{action:`noop`,view:e}:{action:`rejected`,reason:`Task "${e.taskId}" is already ${e.status}; "${t.kind}" cannot change a terminal task.`,view:e};let n={metadata:e.metadata,taskId:e.taskId};if(t.kind===`outcome`){let e=t.result;return{action:`accepted`,view:e.status===`completed`?{...n,status:`completed`,lastOutput:{type:`result`,data:e.output}}:e.status===`failed`?{...n,status:`failed`,lastOutput:{type:`error`,data:workflowToolRunFailureOutput(t)}}:{...n,status:`cancelled`}}}switch(t.kind){case`reject-dispatch`:return{action:`accepted`,view:{...n,lastOutput:{data:t.data,type:`error`},status:`failed`}};case`cancel`:return{action:`accepted`,view:t.usage===void 0?{...n,status:`cancelled`}:{...n,status:`cancelled`,usage:t.usage}};case`require-input`:return isValidInputRequestBatch(t.inputRequests)?{action:`accepted`,view:{inputRequests:t.inputRequests,metadata:e.metadata,status:`input_required`,taskId:e.taskId}}:{action:`rejected`,reason:`Task "${e.taskId}" received an invalid input request batch.`,view:e};case`ready`:return{action:`accepted`,view:e};case`answered`:{if(e.status!==`input_required`)return{action:`noop`,view:e};let n=new Set(t.requestIds),r=e.inputRequests.filter(e=>{let t=readTaskInputRequestId(e);return t===void 0||!n.has(t)});return r.length===e.inputRequests.length?{action:`noop`,view:e}:r.length>0?{action:`accepted`,view:{...e,inputRequests:r}}:{action:`accepted`,view:{metadata:e.metadata,status:`working`,taskId:e.taskId}}}}}function isValidInputRequestBatch(e){if(e.length===0)return!1;let t=e.map(readTaskInputRequestId);return t.every(e=>e!==void 0&&e.length>0)&&new Set(t).size===t.length}export{applyTaskTransition};

package/dist/src/tasks/types.d.ts

@@ -1,138 +0,0 @@
-import type { SubagentAuthorizationEvent, SubagentAuthorizationEventHookPayload } from "#channel/types.js";
-import type { WorkflowToolAgentRequest } from "#execution/tools/workflow/messages.js";
-import type { SessionInboxAddress } from "#execution/session-inbox/address.js";
-import { type JsonValue } from "#shared/json.js";
-import type { ToolInputResponseResponder } from "#tools/definition.js";
-/** Durable lifecycle status for one unit of background work. */
-export type TaskStatus = "working" | "input_required" | "completed" | "failed" | "cancelled";
-/** Executor-neutral identity shown for one task. */
-export interface TaskMetadata {
-    readonly kind: string;
-    readonly name: string;
-    readonly [key: string]: JsonValue | undefined;
-}
-export declare function sameTaskMetadata(left: TaskMetadata, right: TaskMetadata): boolean;
-export type TaskOutput = {
-    readonly type: "result";
-    readonly data: JsonValue;
-} | {
-    readonly type: "error";
-    readonly data: JsonValue;
-};
-/** An outstanding request carried opaquely by the task lifecycle. */
-export type TaskInputRequest = JsonValue;
-export interface TaskUsage {
-    readonly cacheReadTokens: number;
-    readonly cacheWriteTokens: number;
-    readonly costUsd?: number;
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-}
-/** Reads valid provider usage without making task settlement depend on it. */
-export declare function readTaskUsage(value: unknown): TaskUsage | undefined;
-/** Reads the request identity from one opaque request. */
-export declare function readTaskInputRequestId(request: TaskInputRequest): string | undefined;
-interface TaskViewBase {
-    readonly taskId: string;
-    readonly metadata: TaskMetadata;
-    /** Retained for accounting, excluded from model-visible JSON. */
-    readonly usage?: TaskUsage;
-}
-export type TaskView = TaskViewBase & ({
-    readonly status: "working";
-    readonly inputRequests?: never;
-    readonly lastOutput?: never;
-} | {
-    readonly status: "input_required";
-    readonly inputRequests: readonly TaskInputRequest[];
-    readonly lastOutput?: never;
-} | {
-    readonly status: "completed";
-    readonly inputRequests?: never;
-    readonly lastOutput: Extract<TaskOutput, {
-        type: "result";
-    }>;
-} | {
-    readonly status: "failed";
-    readonly inputRequests?: never;
-    readonly lastOutput: Extract<TaskOutput, {
-        type: "error";
-    }>;
-} | {
-    readonly status: "cancelled";
-    readonly inputRequests?: never;
-    readonly lastOutput?: never;
-});
-/** Admission, cancellation, and input state changes for a background invocation. */
-export type TaskCommand = {
-    readonly kind: "reject-dispatch";
-    readonly data: JsonValue;
-} | {
-    readonly kind: "cancel";
-    readonly usage?: TaskUsage;
-} | {
-    readonly kind: "require-input";
-    readonly inputRequests: readonly TaskInputRequest[];
-} | {
-    readonly kind: "ready";
-} | {
-    readonly kind: "answered";
-    readonly requestIds: readonly string[];
-};
-export interface TaskCommandHookPayload {
-    readonly kind: "task-command";
-    readonly command: TaskCommand;
-}
-/** One human answer routed through the task that owns the blocked executor. */
-export interface TaskInboundAnswerInput {
-    readonly auth?: unknown;
-    readonly childContinuationToken: string;
-    readonly childSessionInbox?: SessionInboxAddress;
-    readonly childResponseUrl?: string;
-    readonly inputResponses: readonly {
-        readonly optionId?: string;
-        readonly requestId: string;
-        readonly text?: string;
-    }[];
-    readonly responder?: ToolInputResponseResponder;
-    readonly kind: "input-response";
-    readonly taskId: string;
-}
-export type TaskRunInboundPayload = TaskCommandHookPayload | TaskInboundAnswerInput;
-/** Generic task-owned request sent through the parent session payload. */
-interface TaskInputRequestDeliveryBase {
-    readonly replyTo: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly taskId: string;
-    readonly turnId: string;
-}
-export type TaskInputRequestDelivery = TaskInputRequestDeliveryBase & ({
-    readonly request: TaskInputRequest;
-    readonly requests?: never;
-} | {
-    readonly request?: never;
-    readonly requests: readonly TaskInputRequest[];
-});
-/**
- * Child authorization event projected through the parent channel. Display
- * only: the authorization callback completes against the child directly.
- */
-export interface TaskAuthorizationEventDelivery {
-    readonly hookPayload: SubagentAuthorizationEventHookPayload;
-    readonly taskId: string;
-}
-/** Stable id shared by one authorization attempt's events, used to dedupe deliveries. */
-export declare function taskAuthorizationRequestId(event: SubagentAuthorizationEvent): string;
-/**
- * Agent spawn or settlement a task-owned workflow tool run asks its parent to
- * apply, forwarded after task admission. `replyTo` is the run's reply hook.
- */
-export interface TaskAgentRequestDelivery {
-    readonly replyTo: string;
-    readonly request: WorkflowToolAgentRequest;
-    readonly taskId: string;
-}
-export declare function isTerminalTaskStatus(status: TaskStatus): boolean;
-export declare function isReadyTaskStatus(status: TaskStatus): boolean;
-export {};

package/dist/src/tasks/types.js

@@ -1 +0,0 @@
-import{jsonValuesEqual}from"#shared/json.js";function sameTaskMetadata(e,t){return jsonValuesEqual(e,t)}function readTaskUsage(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=readUsageAxis(e,`cacheReadTokens`),n=readUsageAxis(e,`cacheWriteTokens`),r=readUsageAxis(e,`costUsd`),i=readUsageAxis(e,`inputTokens`),a=readUsageAxis(e,`outputTokens`);if(t===void 0||n===void 0||i===void 0||a===void 0)return;let o={cacheReadTokens:t,cacheWriteTokens:n,inputTokens:i,outputTokens:a};return r!==void 0&&(o.costUsd=r),o}function readUsageAxis(e,t){let n=Reflect.get(e,t);return typeof n==`number`&&Number.isFinite(n)&&n>=0?n:void 0}function readTaskInputRequestId(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`requestId`);return typeof t==`string`?t:void 0}const TASK_AUTHORIZATION_REQUEST_ID_PREFIX=`task:authorization`;function taskAuthorizationRequestId(e){return e.type===`approval.candidate`||e.type===`approval.settled`?`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${e.data.requestId}`:`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${e.data.attemptId??e.data.name}`}function isTerminalTaskStatus(e){return e===`completed`||e===`failed`||e===`cancelled`}function isReadyTaskStatus(e){return e===`input_required`||isTerminalTaskStatus(e)}export{isReadyTaskStatus,isTerminalTaskStatus,readTaskInputRequestId,readTaskUsage,sameTaskMetadata,taskAuthorizationRequestId};

package/dist/src/tools/framework/connection-search.d.ts

@@ -1,3 +0,0 @@
-/** Canonical definition for dynamic connection tool discovery. */
-export declare const connectionSearch: import("#dynamic/definition.js").DynamicSentinel<Record<string, object> | null>;
-export default connectionSearch;

package/dist/src/tools/framework/connection-search.js

@@ -1 +0,0 @@
-import{defineDynamic}from"#dynamic/definition.js";import{resolveConnectionSearchDynamicTools}from"#execution/tools/connection-search.js";const connectionSearch=defineDynamic({events:{"step.started":resolveConnectionSearchDynamicTools}});export{connectionSearch,connectionSearch as default};

package/dist/src/tools/framework/task-cancel.d.ts

@@ -1,4 +0,0 @@
-export declare const taskCancel: import("../definition.ts").PublicToolDefinition<{
-    taskIds: string[];
-}, unknown>;
-export default taskCancel;

package/dist/src/tools/framework/task-cancel.js

@@ -1 +0,0 @@
-import{TASK_CANCEL_INPUT_SCHEMA,TASK_VIEWS_OUTPUT_SCHEMA}from"#tools/framework/task-contract.js";import{defineNativeTool}from"#tools/native-definition.js";const taskCancel=defineNativeTool({description:`Request cooperative cancellation of one or more background tasks. Cancellation is final: a task that finishes after you cancel it stays cancelled. Cancelling an already-finished task changes nothing.`,inputSchema:TASK_CANCEL_INPUT_SCHEMA,outputSchema:TASK_VIEWS_OUTPUT_SCHEMA},{availability:[`root-session`],handling:{action:`task-cancel`,kind:`dispatch`}});export{taskCancel as default,taskCancel};

package/dist/src/tools/framework/task-contract.d.ts

@@ -1,19 +0,0 @@
-export declare const TASK_CANCEL_TOOL_NAME = "task_cancel";
-/** Framework task-control tool names lowered by the runtime. */
-export declare const TASK_TOOL_NAMES: ReadonlySet<string>;
-export declare const TASK_CANCEL_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<{
-    taskIds: string[];
-}, {
-    taskIds: string[];
-}>;
-/**
- * Broad schema advertised by task-control tool outputs. Objects stay open so
- * task metadata can grow without breaking consumers of the output contract.
- */
-export declare const TASK_VIEWS_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<unknown, unknown>;
-export interface SubagentTaskReceipt {
-    agentId: string;
-    status: "working";
-    taskId: string;
-}
-export declare const SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<SubagentTaskReceipt, SubagentTaskReceipt>;

package/dist/src/tools/framework/task-contract.js

@@ -1 +0,0 @@
-import{defineJsonSchema}from"#tools/schema.js";const TASK_CANCEL_TOOL_NAME=`task_cancel`,TASK_TOOL_NAMES=new Set([TASK_CANCEL_TOOL_NAME]),TASK_CANCEL_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{taskIds:{type:`array`,minItems:1,items:{type:`string`,minLength:1},description:`Task ids from earlier subagent task receipts.`}},required:[`taskIds`],additionalProperties:!1}),TASK_VIEWS_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{tasks:{type:`array`,items:{type:`object`,properties:{inputRequests:{type:`array`,items:{}},lastOutput:{type:`object`,properties:{data:{},type:{type:`string`,enum:[`result`,`error`]}},required:[`data`,`type`]},metadata:{type:`object`,properties:{agentId:{type:`string`},kind:{type:`string`},mode:{type:`string`,enum:[`local`,`remote`]},name:{type:`string`}},required:[`kind`,`name`]},status:{type:`string`,enum:[`working`,`input_required`,`completed`,`failed`,`cancelled`]},taskId:{type:`string`}},required:[`metadata`,`status`,`taskId`]}}},required:[`tasks`]}),SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{agentId:{type:`string`},status:{type:`string`,const:`working`},taskId:{type:`string`}},required:[`agentId`,`status`,`taskId`],additionalProperties:!1});export{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,TASK_CANCEL_INPUT_SCHEMA,TASK_CANCEL_TOOL_NAME,TASK_TOOL_NAMES,TASK_VIEWS_OUTPUT_SCHEMA};

package/dist/src/tools/native-definition.d.ts

@@ -1,7 +0,0 @@
-import type { PublicToolDefinition } from "#tools/definition.js";
-import { type CompiledToolBehavior } from "#tools/behavior.js";
-/** Framework-only tool definition whose implementation is owned outside an executor. */
-type NativeToolDefinition<TInput = unknown, TOutput = unknown> = PublicToolDefinition<TInput, TOutput>;
-/** Defines an execute-less framework tool with closed internal behavior. */
-export declare function defineNativeTool<TInput = unknown, TOutput = unknown>(definition: NativeToolDefinition<TInput, TOutput>, behavior: CompiledToolBehavior): NativeToolDefinition<TInput, TOutput>;
-export {};

package/dist/src/tools/native-definition.js

@@ -1 +0,0 @@
-import{attachToolBehavior}from"#tools/behavior.js";function defineNativeTool(e,t){return attachToolBehavior(e,t)}export{defineNativeTool};

package/dist/src/tracing/agent-invocation-terminal.d.ts

@@ -1,18 +0,0 @@
-import type { RuntimeSubagentChildResult } from "#shared/action-types.js";
-import type { AgentActionTraceTerminalState } from "#tracing/agent-trace-state.js";
-export declare function recordNestedAgentInvocationTerminal(input: {
-    readonly callId: string;
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionId: string;
-    readonly terminal: AgentActionTraceTerminalState;
-    readonly turnId?: string;
-}): Record<string, unknown>;
-export declare function settleAgentInvocationTrace(input: {
-    readonly acceptedAtMs: number;
-    readonly result: RuntimeSubagentChildResult;
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionId: string;
-}): Record<string, unknown>;
-/** Called inside dispatch/settlement steps, so replay reuses the flushed context. */
-export declare function flushAgentInvocationTraces(serializedContext: Record<string, unknown>): Promise<Record<string, unknown>>;
-export declare function invocationError(value: unknown): Error;

package/dist/src/tracing/agent-invocation-terminal.js

@@ -1 +0,0 @@
-import{createLogger,formatError}from"#internal/logging.js";import{contextStorage}from"#context/container.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{getInstrumentationRuntime}from"#instrumentation/runtime.js";import{truncateTelemetryText}from"#tracing/telemetry-budget.js";import{AGENT_TRACE_CONTEXT_KEY,deserializeAgentTraceContextState,serializeAgentTraceContextState}from"#tracing/agent-trace-context-codec.js";import{boundedTraceError}from"#tracing/bounded-error.js";const log=createLogger(`tracing.agent-invocation-terminal`);function recordNestedAgentInvocationTerminal(e){let t=e.serializedContext[AGENT_TRACE_CONTEXT_KEY];if(t===void 0)return e.serializedContext;let n=deserializeAgentTraceContextState(t),r=Object.entries(n.invocations).find(([,t])=>t.sessionId===e.sessionId&&(e.turnId===void 0||t.turnId===e.turnId)&&t.callId===e.callId);if(r===void 0)return e.serializedContext;let[i,a]=r;return a.terminal===void 0?{...e.serializedContext,[AGENT_TRACE_CONTEXT_KEY]:serializeAgentTraceContextState({...n,invocations:{...n.invocations,[i]:{...a,terminal:{...e.terminal,error:a.recordOutputs===!0&&e.terminal.error!==void 0?invocationError(e.terminal.error):void 0}}}})}:e.serializedContext}function settleAgentInvocationTrace(e){let t=e.result.outcome.result,n=e.result.usage??e.result.outcome.usageDelta;return recordNestedAgentInvocationTerminal({callId:e.result.callId,serializedContext:e.serializedContext,sessionId:e.sessionId,terminal:{acceptedAtMs:e.acceptedAtMs,error:t.kind===`failed`?invocationError(t.error):void 0,outcome:t.kind===`succeeded`?`completed`:t.kind===`cancelled`?`cancelled`:`failed`,usage:{inputTokenDetails:{cacheReadTokens:n.cacheReadTokens,cacheWriteTokens:n.cacheWriteTokens},inputTokens:n.inputTokens,outputTokens:n.outputTokens}}})}async function flushAgentInvocationTraces(e){if(e[AGENT_TRACE_CONTEXT_KEY]===void 0)return e;let t=getInstrumentationRuntime();if(t?.flushSettledInvocations===void 0)return e;try{let n=await deserializeContext(e);return await contextStorage.run(n,t.flushSettledInvocations),{...e,[AGENT_TRACE_CONTEXT_KEY]:serializeContext(n)[AGENT_TRACE_CONTEXT_KEY]}}catch(t){return log.warn(`could not materialize settled invocation traces`,{error:formatError(t)}),e}}function invocationError(e){return e instanceof Error?boundedTraceError(e):typeof e==`object`&&e&&`message`in e?Error(truncateTelemetryText(String(e.message),4096)):Error(typeof e==`string`?truncateTelemetryText(e,4096):`Agent invocation failed.`)}export{flushAgentInvocationTraces,invocationError,recordNestedAgentInvocationTerminal,settleAgentInvocationTrace};