@relayfx/sdk 0.0.37 → 0.0.39

package/dist/index.js

@@ -39,8 +39,10 @@ __export(exports_client, {
   startExecutionByAgentDefinition: () => startExecutionByAgentDefinition,
   startExecutionByAddress: () => startExecutionByAddress,
   startExecution: () => startExecution,
+  start: () => start2,
   spawnChildRun: () => spawnChildRun2,
   send: () => send3,
+  run: () => run5,
   routeExecution: () => routeExecution,
   resolveToolApproval: () => resolveToolApproval,
   resolvePermission: () => resolvePermission,
@@ -70,6 +72,7 @@ __export(exports_client, {
   claimEnvelopeReady: () => claimEnvelopeReady,
   cancelSchedule: () => cancelSchedule,
   cancelExecution: () => cancelExecution2,
+  agent: () => agent,
   ackEnvelopeReady: () => ackEnvelopeReady,
   Service: () => Service50,
   ClientError: () => ClientError
@@ -128,7 +131,7 @@ __export(exports_ids_schema, {
   EnvelopeReadyId: () => EnvelopeReadyId,
   EnvelopeId: () => EnvelopeId,
   ChildExecutionId: () => ChildExecutionId,
-  AgentDefinitionId: () => AgentDefinitionId,
+  AgentId: () => AgentId,
   AddressId: () => AddressId,
   AddressBookEntryId: () => AddressBookEntryId
 });
@@ -143,7 +146,7 @@ var AddressId = id("Relay.AddressId");
 var TenantId = id("Relay.TenantId");
 var SystemTenantId = TenantId.make("system");
 var AddressBookEntryId = id("Relay.AddressBookEntryId");
-var AgentDefinitionId = id("Relay.AgentDefinitionId");
+var AgentId = id("Relay.AgentId");
 var SkillDefinitionId = id("Relay.SkillDefinitionId");
 var EnvelopeId = id("Relay.EnvelopeId");
 var EnvelopeReadyId = id("Relay.EnvelopeReadyId");
@@ -409,7 +412,7 @@ var define = (input) => ({
   }
 });
 var DefinitionRecord = Schema5.Struct({
-  id: AgentDefinitionId,
+  id: AgentId,
   current_revision: DefinitionRevision,
   definition: Definition2,
   tool_input_schema_digests: Schema5.optionalKey(ToolInputSchemaDigests),
@@ -417,14 +420,14 @@ var DefinitionRecord = Schema5.Struct({
   updated_at: TimestampMillis
 }).annotate({ identifier: "Relay.Agent.DefinitionRecord" });
 var DefinitionRevisionRecord = Schema5.Struct({
-  id: AgentDefinitionId,
+  id: AgentId,
   revision: DefinitionRevision,
   definition: Definition2,
   tool_input_schema_digests: Schema5.optionalKey(ToolInputSchemaDigests),
   created_at: TimestampMillis
 }).annotate({ identifier: "Relay.Agent.DefinitionRevisionRecord" });
 var RegisterDefinitionPayload = Schema5.Struct({
-  id: AgentDefinitionId,
+  id: AgentId,
   definition: Definition2
 }).annotate({ identifier: "Relay.Agent.RegisterDefinitionPayload" });
 var DefinitionRegistered = Schema5.Struct({
@@ -576,7 +579,7 @@ var Execution = Schema8.Struct({
   root_address_id: AddressId,
   session_id: Schema8.optionalKey(SessionId),
   status: ExecutionStatus,
-  agent_definition_id: Schema8.optionalKey(AgentDefinitionId),
+  agent_definition_id: Schema8.optionalKey(AgentId),
   agent_definition_revision: Schema8.optionalKey(DefinitionRevision),
   agent_definition_snapshot: Schema8.optionalKey(Definition2),
   agent_definition_tool_input_schema_digests: Schema8.optionalKey(ToolInputSchemaDigests),
@@ -1282,7 +1285,7 @@ var rowDigests = (json) => nonEmptyDigests(decodeJson(json));
 var toRecord2 = (row) => {
   const toolInputSchemaDigests = rowDigests(row.tool_input_schema_digests_json);
   return {
-    id: exports_ids_schema.AgentDefinitionId.make(row.id),
+    id: exports_ids_schema.AgentId.make(row.id),
     currentRevision: row.current_revision,
     definition: cloneDefinition(decodeJson(row.definition_json)),
     ...toolInputSchemaDigests === undefined ? {} : { toolInputSchemaDigests },
@@ -1293,7 +1296,7 @@ var toRecord2 = (row) => {
 var toRevisionRecord = (row) => {
   const toolInputSchemaDigests = rowDigests(row.tool_input_schema_digests_json);
   return {
-    id: exports_ids_schema.AgentDefinitionId.make(row.agent_definition_id),
+    id: exports_ids_schema.AgentId.make(row.agent_definition_id),
     revision: row.revision,
     definition: cloneDefinition(decodeJson(row.definition_json)),
     ...toolInputSchemaDigests === undefined ? {} : { toolInputSchemaDigests },
@@ -3145,7 +3148,7 @@ var metadata4 = (input) => input ?? {};
 var nonEmptyDigests2 = (digests) => digests === undefined || Object.keys(digests).length === 0 ? undefined : structuredClone(digests);
 var hasCompleteAgentDefinitionPin = (input) => {
   const present = [
-    input.agentDefinitionId !== undefined,
+    input.agentId !== undefined,
     input.agentDefinitionRevision !== undefined,
     input.agentDefinitionSnapshot !== undefined
   ];
@@ -3181,7 +3184,7 @@ var toRecord5 = (row) => {
     rootAddressId: exports_ids_schema.AddressId.make(row.root_address_id),
     ...row.session_id === null || row.session_id === undefined ? {} : { sessionId: exports_ids_schema.SessionId.make(row.session_id) },
     status: row.status,
-    ...row.agent_definition_id === null || row.agent_definition_id === undefined ? {} : { agentDefinitionId: exports_ids_schema.AgentDefinitionId.make(row.agent_definition_id) },
+    ...row.agent_definition_id === null || row.agent_definition_id === undefined ? {} : { agentId: exports_ids_schema.AgentId.make(row.agent_definition_id) },
     ...row.agent_definition_revision === null || row.agent_definition_revision === undefined ? {} : { agentDefinitionRevision: row.agent_definition_revision },
     ...snapshotJson === null || snapshotJson === undefined ? {} : { agentDefinitionSnapshot: cloneAgentDefinition(decodeJson(snapshotJson)) },
     ...digests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: digests },
@@ -3231,7 +3234,7 @@ var layer11 = Layer12.effect(Service12, Effect12.gen(function* () {
         ${input.rootAddressId},
         ${input.sessionId ?? null},
         ${input.status},
-        ${input.agentDefinitionId ?? null},
+        ${input.agentId ?? null},
         ${input.agentDefinitionRevision ?? null},
         ${input.agentDefinitionSnapshot === undefined ? null : encodeJson(input.agentDefinitionSnapshot)},
         ${encodeJson(input.agentDefinitionToolInputSchemaDigests ?? {})},
@@ -3337,7 +3340,7 @@ var memoryLayer9 = Layer12.sync(Service12, () => {
         rootAddressId: input.rootAddressId,
         ...input.sessionId === undefined ? {} : { sessionId: input.sessionId },
         status: input.status,
-        ...input.agentDefinitionId === undefined ? {} : { agentDefinitionId: input.agentDefinitionId },
+        ...input.agentId === undefined ? {} : { agentId: input.agentId },
         ...input.agentDefinitionRevision === undefined ? {} : { agentDefinitionRevision: input.agentDefinitionRevision },
         ...input.agentDefinitionSnapshot === undefined ? {} : { agentDefinitionSnapshot: cloneAgentDefinition(input.agentDefinitionSnapshot) },
         ...input.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: structuredClone(input.agentDefinitionToolInputSchemaDigests) },
@@ -4065,7 +4068,7 @@ var relayAgentDefinitions = pgTable("relay_agent_definitions", {
 ]);
 var relayAgentDefinitionRevisions = pgTable("relay_agent_definition_revisions", {
   tenantId: tenantId(),
-  agentDefinitionId: text2("agent_definition_id").$type().notNull(),
+  agentId: text2("agent_definition_id").$type().notNull(),
   revision: integer("revision").$type().notNull(),
   name: text2("name").notNull(),
   definitionJson: jsonb("definition_json").$type().notNull(),
@@ -4073,10 +4076,10 @@ var relayAgentDefinitionRevisions = pgTable("relay_agent_definition_revisions",
   createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
 }, (table) => [
   primaryKey({
-    columns: [table.tenantId, table.agentDefinitionId, table.revision],
+    columns: [table.tenantId, table.agentId, table.revision],
     name: "pk_relay_agent_definition_revisions"
   }),
-  index("idx_relay_agent_definition_revisions_definition").on(table.tenantId, table.agentDefinitionId, table.revision)
+  index("idx_relay_agent_definition_revisions_definition").on(table.tenantId, table.agentId, table.revision)
 ]);
 var relaySkillDefinitions = pgTable("relay_skill_definitions", {
   tenantId: tenantId(),
@@ -4235,7 +4238,7 @@ var relayExecutions = pgTable("relay_executions", {
   rootAddressId: text2("root_address_id").$type().notNull(),
   sessionId: text2("session_id").$type(),
   status: text2("status").$type().notNull(),
-  agentDefinitionId: text2("agent_definition_id").$type(),
+  agentId: text2("agent_definition_id").$type(),
   agentDefinitionRevision: integer("agent_definition_revision").$type(),
   agentDefinitionSnapshotJson: jsonb("agent_definition_snapshot_json").$type(),
   agentDefinitionToolInputSchemaDigestsJson: jsonb("agent_definition_tool_input_schema_digests_json").$type().notNull().default({}),
@@ -7218,15 +7221,16 @@ var digestDefinitions = Effect25.fn("ToolInputSchemaDigest.digestDefinitions")(f
 // ../runtime/src/tool/tool-runtime-service.ts
 var exports_tool_runtime_service = {};
 __export(exports_tool_runtime_service, {
+  toolFromRegistered: () => toolFromRegistered,
+  tool: () => tool,
   testLayer: () => testLayer23,
   run: () => run,
   registeredTools: () => registeredTools,
   register: () => register2,
   memoryLayer: () => memoryLayer23,
   layer: () => layer23,
+  dynamicTool: () => dynamicTool,
   definitions: () => definitions,
-  definitionFromAiTool: () => definitionFromAiTool,
-  aiToolFromRegistered: () => aiToolFromRegistered,
   ToolRuntimeError: () => ToolRuntimeError,
   ToolPermissionDenied: () => ToolPermissionDenied,
   ToolNotRegistered: () => ToolNotRegistered,
@@ -7237,7 +7241,7 @@ __export(exports_tool_runtime_service, {
   Service: () => Service26
 });
 import * as Ai from "effect/unstable/ai";
-import { Chunk, Context as Context26, Effect as Effect28, HashSet as HashSet3, Layer as Layer26, Option as Option6, Ref as Ref6, Schema as Schema35, Sink, Stream as Stream4 } from "effect";
+import { Chunk, Context as Context26, Effect as Effect28, HashSet as HashSet3, Layer as Layer26, Option as Option6, Ref as Ref6, Schema as Schema35 } from "effect";
 
 // ../runtime/src/execution/event-log-service.ts
 var exports_event_log_service = {};
@@ -7789,9 +7793,9 @@ var ensureAllowed = (tool, input) => {
   return Effect28.fail(new ToolPermissionDenied({ tool_name: input.call.name, permission_name: missing }));
 };
 var validateInput = (tool, input) => {
-  if (tool.inputSchema === undefined)
+  if (tool.validateInput === undefined)
     return Effect28.void;
-  return Schema35.decodeUnknownEffect(tool.inputSchema)(input.call.input).pipe(Effect28.mapError((error) => new ToolInputInvalid({ tool_name: input.call.name, message: error.message })), Effect28.asVoid);
+  return tool.validateInput(input.call.input);
 };
 var mapRepositoryError4 = (error) => new ToolRuntimeError({ message: error._tag });
 var mapEventLogError2 = (error) => new ToolRuntimeError({ message: error._tag });
@@ -7848,58 +7852,25 @@ var upsertTool = (registry, tool) => {
 var registerTool = (tools, tool) => Ref6.update(tools, (registry) => upsertTool(registry, tool));
 var jsonValue = (value) => Schema35.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var fallbackParametersSchema = Schema35.Struct({});
-var parametersForRegisteredTool = (inputSchema) => {
+var parametersForInputSchema = (inputSchema) => {
   const schema = exports_tool_schema.parametersSchema(inputSchema);
   return schema.ast._tag === "Unknown" ? { parameters: fallbackParametersSchema, jsonSchema: inputSchema } : { parameters: schema };
 };
 var attachJsonSchema = (tool, jsonSchema) => jsonSchema === undefined ? tool : Object.assign(tool, { jsonSchema });
-var aiToolFromRegistered = (tool) => {
-  if (tool.aiTool !== undefined)
-    return tool.aiTool;
-  const parameters = parametersForRegisteredTool(tool.definition.input_schema);
-  return attachJsonSchema(Ai.Tool.dynamic(tool.definition.name, {
-    description: tool.definition.description,
-    parameters: parameters.parameters,
-    success: Schema35.Unknown,
-    needsApproval: tool.definition.needs_approval
-  }), parameters.jsonSchema);
-};
-var handlerForTool = (tool, input) => (params, context) => {
-  const callInfo = ToolCallInfo.of({
-    executionId: input.executionId,
-    call: input.call,
-    permissions: input.permissions,
-    eventSequence: input.eventSequence,
-    createdAt: input.createdAt
-  });
-  return (tool.handler === undefined ? tool.run(jsonValue(params), {
+var toolFromRegistered = (tool) => tool.tool;
+var finalToolResult = (tool, input) => Effect28.gen(function* () {
+  const context = {
     executionId: input.executionId,
     call: input.call,
     permissions: input.permissions,
     eventSequence: input.eventSequence,
     createdAt: input.createdAt
-  }) : tool.handler(params, context)).pipe(Effect28.provideService(ToolCallInfo, callInfo));
-};
-var toolkitForCall = (tool, input) => {
-  const aiTool = aiToolFromRegistered(tool);
-  const toolkit = Ai.Toolkit.make(aiTool);
-  const handlers = { [tool.definition.name]: handlerForTool(tool, input) };
-  return toolkit.pipe(Effect28.provide(toolkit.toLayer(handlers)), Effect28.map((withHandler) => withHandler));
-};
-var finalToolResult = (tool, input) => Effect28.gen(function* () {
-  const toolkit = yield* toolkitForCall(tool, input);
-  const stream2 = yield* toolkit.handle(tool.definition.name, input.call.input).pipe(Effect28.map((value) => value), Effect28.mapError((error) => preserveToolError(input.call.name, error)));
-  const result = yield* stream2.pipe(Stream4.filter((item) => item.preliminary === false), Stream4.run(Sink.last()), Effect28.flatMap(Option6.match({
-    onNone: () => Effect28.fail(new ToolExecutionFailed({
-      tool_name: input.call.name,
-      message: "Tool handler did not produce a final result"
-    })),
-    onSome: Effect28.succeed
-  })), Effect28.mapError((error) => preserveToolError(input.call.name, error)));
+  };
+  const callInfo = ToolCallInfo.of(context);
+  const output = yield* tool.run(input.call.input, context).pipe(Effect28.provideService(ToolCallInfo, callInfo), Effect28.mapError((error) => preserveToolError(input.call.name, error)));
   return {
     call_id: input.call.id,
-    output: jsonValue(result.encodedResult),
-    ...result.isFailure ? { error: "Tool handler failed" } : {}
+    output: jsonValue(output)
   };
 });
 var approvalWaitId = (input) => exports_ids_schema.WaitId.make(`wait:approval:${input.call.id}`);
@@ -7973,38 +7944,85 @@ var recordRequested = (repository, eventLog, input) => repository.getCall(input.
   return repository.recordCall({ executionId: input.executionId, call: input.call, createdAt: input.createdAt }).pipe(Effect28.mapError(mapRepositoryError4), Effect28.flatMap(() => appendIdempotentTo(eventLog, requestedEvent(input)).pipe(Effect28.mapError(mapEventLogError2))), Effect28.asVoid);
 }));
 var recordReceived = (repository, eventLog, input, result) => repository.recordResult({ result, createdAt: input.createdAt + 1 }).pipe(Effect28.catchTag("DuplicateToolResult", () => repository.getResult(result.call_id).pipe(Effect28.mapError(mapRepositoryError4), Effect28.flatMap((existing) => existing === undefined ? Effect28.fail(new ToolRuntimeError({ message: "DuplicateToolResult" })) : Effect28.succeed(existing)))), Effect28.mapError(preserveRecordResultError), Effect28.flatMap((record2) => appendIdempotentTo(eventLog, resultEvent(input, record2.result)).pipe(Effect28.mapError(mapEventLogError2), Effect28.as(record2.result))));
-var definitionFromAiTool = (tool, permissions = []) => ({
+var nonEmptyName = (name) => Schema35.decodeUnknownSync(exports_shared_schema.NonEmptyString)(name);
+var definitionFromEffectTool = (tool, options) => ({
   name: tool.name,
   description: Ai.Tool.getDescription(tool) ?? "",
   input_schema: jsonValue(Ai.Tool.getJsonSchema(tool)),
   output_schema: jsonValue(Ai.Tool.getJsonSchemaFromSchema(tool.successSchema)),
-  permissions
-});
+  permissions: options.permissions ?? [],
+  ...options.requirements === undefined ? {} : { requirements: options.requirements },
+  ...options.needsApproval === undefined ? {} : { needs_approval: options.needsApproval },
+  ...options.metadata === undefined ? {} : { metadata: options.metadata }
+});
+var tool = (name, options) => {
+  const effectTool = Ai.Tool.make(name, {
+    description: options.description,
+    parameters: options.input,
+    success: options.output,
+    failureMode: "return",
+    needsApproval: options.needsApproval
+  });
+  const definition = definitionFromEffectTool(effectTool, options);
+  return {
+    name: nonEmptyName(name),
+    definition,
+    tool: effectTool,
+    ...options.requiredPermissions === undefined ? {} : { requiredPermissions: options.requiredPermissions },
+    validateInput: (input) => Schema35.decodeUnknownEffect(options.input)(input).pipe(Effect28.mapError((error) => new ToolInputInvalid({ tool_name: name, message: error.message })), Effect28.asVoid),
+    run: (input, context) => Schema35.decodeUnknownEffect(options.input)(input).pipe(Effect28.flatMap((decoded) => options.run(decoded, context)), Effect28.flatMap(Schema35.encodeUnknownEffect(options.output)), Effect28.map(jsonValue))
+  };
+};
+var dynamicTool = (name, options) => {
+  const parameters = parametersForInputSchema(options.inputSchema);
+  const modelTool = attachJsonSchema(Ai.Tool.dynamic(name, {
+    description: options.description,
+    parameters: parameters.parameters,
+    success: Schema35.Unknown,
+    needsApproval: options.needsApproval
+  }), parameters.jsonSchema);
+  return {
+    name: nonEmptyName(name),
+    definition: {
+      name: nonEmptyName(name),
+      description: options.description,
+      input_schema: options.inputSchema,
+      output_schema: options.outputSchema,
+      permissions: options.permissions ?? [],
+      ...options.requirements === undefined ? {} : { requirements: options.requirements },
+      ...options.needsApproval === undefined ? {} : { needs_approval: options.needsApproval },
+      ...options.metadata === undefined ? {} : { metadata: options.metadata }
+    },
+    tool: modelTool,
+    ...options.requiredPermissions === undefined ? {} : { requiredPermissions: options.requiredPermissions },
+    run: options.run
+  };
+};
 var layer23 = (initialTools = []) => Layer26.effect(Service26, Effect28.gen(function* () {
   const repository = yield* exports_tool_call_repository.Service;
   const eventLog = yield* Service24;
   const waits = yield* Service25;
   const tools = yield* Ref6.make(initialTools.reduce(upsertTool, Chunk.empty()));
   return Service26.of({
-    register: Effect28.fn("ToolRuntime.register")((tool) => registerTool(tools, tool)),
-    definitions: Ref6.get(tools).pipe(Effect28.map((registry) => Chunk.toReadonlyArray(Chunk.map(registry, (tool) => tool.definition)))),
+    register: Effect28.fn("ToolRuntime.register")((registeredTool) => registerTool(tools, registeredTool)),
+    definitions: Ref6.get(tools).pipe(Effect28.map((registry) => Chunk.toReadonlyArray(Chunk.map(registry, (registeredTool) => registeredTool.definition)))),
     registeredTools: Ref6.get(tools).pipe(Effect28.map(Chunk.toReadonlyArray)),
     run: Effect28.fn("ToolRuntime.run")(function* (input) {
       const stored = yield* Ref6.get(tools);
       const registry = (input.extraTools ?? []).reduce(upsertTool, stored);
-      const tool = Chunk.findFirst(registry, sameToolName(input.call.name)).pipe(Option6.getOrUndefined);
-      if (tool === undefined) {
+      const registeredTool = Chunk.findFirst(registry, sameToolName(input.call.name)).pipe(Option6.getOrUndefined);
+      if (registeredTool === undefined) {
         return yield* Effect28.fail(new ToolNotRegistered({ tool_name: input.call.name }));
       }
       const existingResult = yield* repository.getResult(input.call.id).pipe(Effect28.mapError(mapRepositoryError4));
       if (existingResult !== undefined)
         return existingResult.result;
       return yield* Effect28.gen(function* () {
-        yield* ensureAllowed(tool, input);
-        yield* validateInput(tool, input);
+        yield* ensureAllowed(registeredTool, input);
+        yield* validateInput(registeredTool, input);
         yield* recordRequested(repository, eventLog, input);
         let effectiveInput = input;
-        if (tool.definition.needs_approval === true) {
+        if (registeredTool.definition.needs_approval === true) {
           const bypass = yield* hasPermissionApprovalBypass(waits, input);
           if (!bypass) {
             const decision = yield* resolveApproval(waits, eventLog, input);
@@ -8020,7 +8038,7 @@ var layer23 = (initialTools = []) => Layer26.effect(Service26, Effect28.gen(func
             }
           }
         }
-        const rawResult = yield* finalToolResult(tool, effectiveInput);
+        const rawResult = yield* finalToolResult(registeredTool, effectiveInput);
         const result = input.transformResult === undefined || rawResult.error !== undefined ? rawResult : yield* input.transformResult(rawResult);
         const received = yield* recordReceived(repository, eventLog, effectiveInput, result);
         yield* recordToolCall(input.call.name, result.error === undefined ? "success" : "failure");
@@ -8031,9 +8049,9 @@ var layer23 = (initialTools = []) => Layer26.effect(Service26, Effect28.gen(func
 }));
 var memoryLayer23 = (tools = []) => layer23(tools).pipe(Layer26.provide(layer22), Layer26.provide(exports_tool_call_repository.memoryLayer), Layer26.provide(exports_envelope_repository.memoryLayer), Layer26.provide(exports_schedule_repository.memoryLayer), Layer26.provide(memoryLayer21));
 var testLayer23 = (implementation) => Layer26.succeed(Service26, Service26.of(implementation));
-var register2 = Effect28.fn("ToolRuntime.register.call")(function* (tool) {
+var register2 = Effect28.fn("ToolRuntime.register.call")(function* (registeredTool) {
   const service = yield* Service26;
-  return yield* service.register(tool);
+  return yield* service.register(registeredTool);
 });
 var definitions = Effect28.fn("ToolRuntime.definitions.call")(function* () {
   const service = yield* Service26;
@@ -8214,7 +8232,7 @@ class AddressRouteKindMismatch extends Schema37.TaggedErrorClass()("AddressRoute
 
 class AddressAgentDefinitionNotFound extends Schema37.TaggedErrorClass()("AddressAgentDefinitionNotFound", {
   address_id: exports_ids_schema.AddressId,
-  agent_definition_id: exports_ids_schema.AgentDefinitionId
+  agent_definition_id: exports_ids_schema.AgentId
 }) {
 }
 
@@ -8230,7 +8248,7 @@ var LocalAgentRoute = Schema37.Struct({
 var LocalAgentTarget = Schema37.Struct({
   address_id: exports_ids_schema.AddressId,
   route: LocalAgentRoute,
-  agent_definition_id: exports_ids_schema.AgentDefinitionId,
+  agent_definition_id: exports_ids_schema.AgentId,
   agent_definition_revision: exports_agent_schema.DefinitionRevision,
   agent_definition_snapshot: exports_agent_schema.Definition,
   tool_input_schema_digests: Schema37.optionalKey(exports_agent_schema.ToolInputSchemaDigests)
@@ -8266,22 +8284,22 @@ var layer25 = Layer28.effect(Service28, Effect30.gen(function* () {
         return yield* Effect30.fail(new AddressRouteNotFound({ address_id: addressId }));
       }
       const route = yield* routeToLocalAgent(addressId, record2.route);
-      const agentDefinitionId = yield* Schema37.decodeUnknownEffect(exports_ids_schema.AgentDefinitionId)(route.route_key).pipe(Effect30.mapError((error) => new AddressResolutionError({ message: String(error) })));
-      const definition = yield* agentRegistry.get(agentDefinitionId).pipe(Effect30.mapError(mapAgentRegistryError));
+      const agentId = yield* Schema37.decodeUnknownEffect(exports_ids_schema.AgentId)(route.route_key).pipe(Effect30.mapError((error) => new AddressResolutionError({ message: String(error) })));
+      const definition = yield* agentRegistry.get(agentId).pipe(Effect30.mapError(mapAgentRegistryError));
       if (definition === undefined) {
         return yield* Effect30.fail(new AddressAgentDefinitionNotFound({
           address_id: addressId,
-          agent_definition_id: agentDefinitionId
+          agent_definition_id: agentId
         }));
       }
       yield* Effect30.annotateCurrentSpan({
-        "relay.agent_definition.id": agentDefinitionId,
+        "relay.agent_definition.id": agentId,
         "relay.agent_definition.revision": definition.current_revision
       });
       return {
         address_id: addressId,
         route,
-        agent_definition_id: agentDefinitionId,
+        agent_definition_id: agentId,
         agent_definition_revision: definition.current_revision,
         agent_definition_snapshot: definition.definition,
         ...definition.tool_input_schema_digests === undefined ? {} : { tool_input_schema_digests: definition.tool_input_schema_digests }
@@ -8297,11 +8315,11 @@ var resolveLocalAgent = Effect30.fn("AddressResolution.resolveLocalAgent.call")(
 // ../runtime/src/agent/agent-loop-service.ts
 var exports_agent_loop_service = {};
 __export(exports_agent_loop_service, {
+  toolFromDefinition: () => toolFromDefinition,
   testLayer: () => testLayer45,
   run: () => run3,
   mapBoundaryError: () => mapBoundaryError,
   layer: () => layer44,
-  aiToolFromDefinition: () => aiToolFromDefinition,
   Service: () => Service41,
   STRUCTURED_TURN_PROMPT: () => STRUCTURED_TURN_PROMPT,
   AgentLoopWaitRequested: () => AgentLoopWaitRequested,
@@ -8319,7 +8337,7 @@ __export(exports_agent, {
   generate: () => generate,
   defaultObjectPrompt: () => defaultObjectPrompt
 });
-import { Cause as Cause3, Effect as Effect44, Fiber, Option as Option15, Queue as Queue2, Ref as Ref10, Stream as Stream7 } from "effect";
+import { Cause as Cause3, Effect as Effect44, Fiber, Option as Option15, Queue as Queue2, Ref as Ref10, Stream as Stream6 } from "effect";
 import * as Ai6 from "effect/unstable/ai";
 
 // ../../node_modules/.bun/@batonfx+core@0.1.1/node_modules/@batonfx/core/src/agent-event.ts
@@ -8890,7 +8908,7 @@ __export(exports_model_resilience, {
   apply: () => apply,
   ModelResilience: () => ModelResilience
 });
-import { Cause, Context as Context36, Effect as Effect38, Layer as Layer36, Schedule as Schedule2, Stream as Stream5 } from "effect";
+import { Cause, Context as Context36, Effect as Effect38, Layer as Layer36, Schedule as Schedule2, Stream as Stream4 } from "effect";
 import * as Ai5 from "effect/unstable/ai";
 
 class ModelResilience extends Context36.Service()("@batonfx/core/ModelResilience") {
@@ -8912,15 +8930,15 @@ var apply = (model, resilience) => ({
   ...model,
   generateText: (options) => retryEffect(() => model.generateText(options), resilience),
   generateObject: (options) => retryEffect(() => model.generateObject(options), resilience),
-  streamText: (options) => Stream5.suspend(() => {
+  streamText: (options) => Stream4.suspend(() => {
     let emitted = false;
-    return model.streamText(options).pipe(Stream5.tap(() => Effect38.sync(() => {
+    return model.streamText(options).pipe(Stream4.tap(() => Effect38.sync(() => {
       emitted = true;
-    })), Stream5.catchCause((cause) => {
+    })), Stream4.catchCause((cause) => {
       const error = Cause.squash(cause);
-      return emitted ? Stream5.make(Ai5.Response.makePart("error", { error })) : Stream5.failCause(cause);
+      return emitted ? Stream4.make(Ai5.Response.makePart("error", { error })) : Stream4.failCause(cause);
     }));
-  }).pipe(Stream5.retry(retryStreamSchedule(resilience)))
+  }).pipe(Stream4.retry(retryStreamSchedule(resilience)))
 });
 
 // ../../node_modules/.bun/@batonfx+core@0.1.1/node_modules/@batonfx/core/src/permissions.ts
@@ -8972,23 +8990,23 @@ var paramsText = (params) => {
   const json = JSON.stringify(params);
   return json === undefined ? String(params) : json;
 };
-var matches = (pattern, tool, params) => {
+var matches = (pattern, tool2, params) => {
   const separator = pattern.indexOf(":");
   if (separator === -1)
-    return glob(pattern).test(tool);
+    return glob(pattern).test(tool2);
   const toolPattern = pattern.slice(0, separator);
   const paramsPattern = pattern.slice(separator + 1);
-  return glob(toolPattern).test(tool) && glob(paramsPattern).test(paramsText(params));
+  return glob(toolPattern).test(tool2) && glob(paramsPattern).test(paramsText(params));
 };
-var matchingRule = (ruleset, tool, params) => {
+var matchingRule = (ruleset, tool2, params) => {
   let matched;
   for (const rule of ruleset.rules) {
-    if (matches(rule.pattern, tool, params))
+    if (matches(rule.pattern, tool2, params))
       matched = rule;
   }
   return matched;
 };
-var evaluate = (ruleset, tool, params) => matchingRule(ruleset, tool, params)?.level ?? ruleset.fallback ?? "ask";
+var evaluate = (ruleset, tool2, params) => matchingRule(ruleset, tool2, params)?.level ?? ruleset.fallback ?? "ask";
 var tokenFor = (request) => `permission:${request.toolCallId ?? `${request.agentName}:${request.turn}:${request.tool}`}`;
 var decisionFor = (ruleset, request) => {
   const rule = matchingRule(ruleset, request.tool, request.params);
@@ -9068,7 +9086,7 @@ __export(exports_tool_executor, {
   fromToolkit: () => fromToolkit,
   ToolExecutor: () => ToolExecutor
 });
-import { Cause as Cause2, Context as Context40, Effect as Effect42, Layer as Layer40, Option as Option14, Sink as Sink2, Stream as Stream6 } from "effect";
+import { Cause as Cause2, Context as Context40, Effect as Effect42, Layer as Layer40, Option as Option14, Sink, Stream as Stream5 } from "effect";
 
 class ToolExecutor extends Context40.Service()("@batonfx/core/ToolExecutor") {
 }
@@ -9093,7 +9111,7 @@ var executeWithToolkit = (toolkit, request) => {
   if (toolkit.tools[request.call.name] === undefined) {
     return Effect42.succeed(failureOutcome(`Tool ${request.call.name} is not registered`));
   }
-  return toolkit.handle(request.call.name, request.call.params).pipe(Effect42.flatMap((results) => results.pipe(Stream6.filter((item) => item.preliminary === false), Stream6.run(Sink2.last()))), Effect42.map(Option14.match({
+  return toolkit.handle(request.call.name, request.call.params).pipe(Effect42.flatMap((results) => results.pipe(Stream5.filter((item) => item.preliminary === false), Stream5.run(Sink.last()))), Effect42.map(Option14.match({
     onNone: () => failureOutcome("Tool handler did not produce a final result"),
     onSome: (result) => result.isFailure ? failureOutcome(resultMessage(result.result)) : {
       _tag: "Success",
@@ -9182,8 +9200,8 @@ var suspended = (call, token, reason) => new AgentSuspended({
 });
 var withSystem = (instructions, prompt) => Ai6.Prompt.fromMessages([Ai6.Prompt.makeMessage("system", { content: instructions }), ...prompt.content]);
 var isUserMessagePart = (part) => part.type === "text" || part.type === "file";
-var approvalRequired = (tool, call, messages) => {
-  const needsApproval = tool?.needsApproval;
+var approvalRequired = (tool2, call, messages) => {
+  const needsApproval = tool2?.needsApproval;
   if (needsApproval === undefined)
     return Effect44.succeed(false);
   if (typeof needsApproval === "boolean")
@@ -9213,7 +9231,7 @@ var applyPartChain = (chain, part, context) => Effect44.gen(function* () {
   }
   return current2;
 });
-var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen(function* () {
+var streamInternal = (agent, options, structured) => Stream6.unwrap(Effect44.gen(function* () {
   const executor = yield* ToolExecutor;
   const approvals = yield* Approvals;
   const chain = yield* ModelMiddleware;
@@ -9270,7 +9288,7 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
   const freshChat = options.history !== undefined ? Ai6.Chat.fromPrompt(options.history) : system !== undefined ? Ai6.Chat.fromPrompt([Ai6.Prompt.makeMessage("system", { content: system })]) : Ai6.Chat.empty;
   const chat = persisted ?? (yield* freshChat);
   const savePersisted = persisted === undefined ? Effect44.void : persisted.save.pipe(Effect44.mapError((error) => new AgentError({ message: errorMessage(error), turn: 0, cause: error })));
-  const failSuspended = (call, token, reason) => Stream7.unwrap(savePersisted.pipe(Effect44.as(Stream7.fail(suspended(call, token, reason)))));
+  const failSuspended = (call, token, reason) => Stream6.unwrap(savePersisted.pipe(Effect44.as(Stream6.fail(suspended(call, token, reason)))));
   const state = {
     text: "",
     turn: 0,
@@ -9376,18 +9394,18 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
       case "Success":
         return boundedSuccessResult(turn, call, outcome).pipe(Effect44.map((result) => {
           state.pending.push(result);
-          return Stream7.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result }]);
+          return Stream6.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result }]);
         }));
       case "Failure": {
         const result = failedResult(call, outcome.message);
         state.pending.push(result);
-        return Effect44.succeed(Stream7.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result }]));
+        return Effect44.succeed(Stream6.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result }]));
       }
       case "Suspend":
         return Effect44.succeed(failSuspended(call, outcome.token, "tool-wait"));
     }
   };
-  const executeApproved = (turn, call, request) => Stream7.concat(Stream7.fromIterable([{ _tag: "ToolExecutionStarted", turn, call }]), Stream7.unwrap(Effect44.gen(function* () {
+  const executeApproved = (turn, call, request) => Stream6.concat(Stream6.fromIterable([{ _tag: "ToolExecutionStarted", turn, call }]), Stream6.unwrap(Effect44.gen(function* () {
     const progressQueue = yield* Queue2.unbounded();
     const signal = yield* Effect44.abortSignal;
     const context = ToolContext.of({
@@ -9405,29 +9423,29 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
       }
     });
     const fiber = yield* executor.execute(request).pipe(Effect44.provideService(ToolContext, context), Effect44.ensuring(Queue2.end(progressQueue).pipe(Effect44.asVoid)), Effect44.forkScoped({ startImmediately: true }));
-    return Stream7.concat(Stream7.fromQueue(progressQueue), Stream7.fromEffect(Fiber.join(fiber)).pipe(Stream7.flatMap((outcome) => Stream7.unwrap(outcomeEvents(turn, call, outcome)))));
+    return Stream6.concat(Stream6.fromQueue(progressQueue), Stream6.fromEffect(Fiber.join(fiber)).pipe(Stream6.flatMap((outcome) => Stream6.unwrap(outcomeEvents(turn, call, outcome)))));
   })));
   const permissionError = (turn, error) => new AgentError({ message: error.message, turn, cause: error });
   const permissionDeniedEvents = (turn, call, reason) => {
     const result = failedResult(call, reason ?? "Permission denied");
     state.pending.push(result);
-    return Stream7.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result }]);
+    return Stream6.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result }]);
   };
   const rememberAlways = (turn, call) => Effect44.serviceOption(RuleStore).pipe(Effect44.flatMap(Option15.match({
     onNone: () => Effect44.void,
     onSome: (store) => store.remember({ pattern: call.name, level: "allow" }).pipe(Effect44.mapError((error) => permissionError(turn, error)))
   })));
-  const approvalEvents = (turn, call, messages, request, tool) => Stream7.unwrap(approvalRequired(tool, call, messages).pipe(Effect44.map((isRequired) => {
+  const approvalEvents = (turn, call, messages, request, tool2) => Stream6.unwrap(approvalRequired(tool2, call, messages).pipe(Effect44.map((isRequired) => {
     if (!isRequired)
       return executeApproved(turn, call, request);
-    return Stream7.concat(Stream7.fromIterable([{ _tag: "ApprovalRequested", turn, call }]), Stream7.unwrap(approvals.check(request).pipe(Effect44.map((decision2) => {
+    return Stream6.concat(Stream6.fromIterable([{ _tag: "ApprovalRequested", turn, call }]), Stream6.unwrap(approvals.check(request).pipe(Effect44.map((decision2) => {
       switch (decision2._tag) {
         case "Approved":
           return executeApproved(turn, call, request);
         case "Denied": {
           const result = failedResult(call, decision2.reason ?? "Tool call denied");
           state.pending.push(result);
-          return Stream7.fromIterable([
+          return Stream6.fromIterable([
             { _tag: "ToolExecutionCompleted", turn, call, result }
           ]);
         }
@@ -9443,7 +9461,7 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
       case "Denied":
         return permissionDeniedEvents(turn, call, answer.reason);
       case "Always":
-        return Stream7.unwrap(rememberAlways(turn, call).pipe(Effect44.as(executeApproved(turn, call, request))));
+        return Stream6.unwrap(rememberAlways(turn, call).pipe(Effect44.as(executeApproved(turn, call, request))));
     }
   };
   const permissionAskEvents = (turn, call, request, token) => {
@@ -9457,17 +9475,17 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
     };
     if (Option15.isNone(permissionsService))
       return failSuspended(call, token, "approval");
-    return Stream7.concat(Stream7.fromIterable([{ _tag: "ApprovalRequested", turn, call }]), Stream7.unwrap(permissionsService.value.await(pending).pipe(Effect44.mapError((error) => permissionError(turn, error)), Effect44.map(Option15.match({
+    return Stream6.concat(Stream6.fromIterable([{ _tag: "ApprovalRequested", turn, call }]), Stream6.unwrap(permissionsService.value.await(pending).pipe(Effect44.mapError((error) => permissionError(turn, error)), Effect44.map(Option15.match({
       onNone: () => failSuspended(call, token, "approval"),
       onSome: (answer) => permissionAnsweredEvents(turn, call, request, answer)
     })))));
   };
   const toolCallEvents = (turn, call, messages) => {
     const request = { call, turn, agentName: agent.name, sessionId };
-    const tool = agent.toolkit.tools[call.name];
+    const tool2 = agent.toolkit.tools[call.name];
     if (Option15.isNone(permissionsService))
-      return approvalEvents(turn, call, messages, request, tool);
-    return Stream7.unwrap(permissionsService.value.evaluate({
+      return approvalEvents(turn, call, messages, request, tool2);
+    return Stream6.unwrap(permissionsService.value.evaluate({
       tool: call.name,
       params: call.params,
       agentName: agent.name,
@@ -9477,7 +9495,7 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
     }).pipe(Effect44.mapError((error) => permissionError(turn, error)), Effect44.map((decision2) => {
       switch (decision2._tag) {
         case "Allow":
-          return approvalEvents(turn, call, messages, request, tool);
+          return approvalEvents(turn, call, messages, request, tool2);
         case "Deny":
           return permissionDeniedEvents(turn, call, decision2.reason);
         case "Ask":
@@ -9515,56 +9533,56 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
   });
   const partEvents = (turn, part, messages) => {
     if (part.type === "error") {
-      return Stream7.fail(new AgentError({ message: errorMessage(part.error), turn, cause: part.error }));
+      return Stream6.fail(new AgentError({ message: errorMessage(part.error), turn, cause: part.error }));
     }
-    const modelPart = Stream7.fromIterable([{ _tag: "ModelPart", turn, part }]);
+    const modelPart = Stream6.fromIterable([{ _tag: "ModelPart", turn, part }]);
     if (part.type === "tool-call") {
       const call = part;
-      return call.providerExecuted === true ? modelPart : Stream7.concat(modelPart, toolCallEvents(turn, call, messages));
+      return call.providerExecuted === true ? modelPart : Stream6.concat(modelPart, toolCallEvents(turn, call, messages));
     }
     if (part.type === "text-delta") {
       state.text = `${state.text}${part.delta}`;
     }
     if (part.type === "finish") {
-      return modelPart.pipe(Stream7.tap(() => captureFinishPart(part)));
+      return modelPart.pipe(Stream6.tap(() => captureFinishPart(part)));
     }
     return modelPart;
   };
-  const applyPartToEvents = (turn, part, messages) => Stream7.unwrap(applyPartChain(chain, part, { agentName: agent.name, turn }).pipe(Effect44.map(Option15.match({
+  const applyPartToEvents = (turn, part, messages) => Stream6.unwrap(applyPartChain(chain, part, { agentName: agent.name, turn }).pipe(Effect44.map(Option15.match({
     onSome: (transformed) => partEvents(turn, transformed, messages),
-    onNone: () => part.type === "tool-call" ? Stream7.fail(new MiddlewareViolation({
+    onNone: () => part.type === "tool-call" ? Stream6.fail(new MiddlewareViolation({
       turn,
       detail: "ModelMiddleware dropped a tool-call part"
-    })) : Stream7.empty
+    })) : Stream6.empty
   }))));
-  const activeToolkit = (activeTools) => Ai6.Toolkit.make(...Object.values(agent.toolkit.tools).filter((tool) => activeTools.includes(tool.name)));
+  const activeToolkit = (activeTools) => Ai6.Toolkit.make(...Object.values(agent.toolkit.tools).filter((tool2) => activeTools.includes(tool2.name)));
   const modelTurn = (turn, prompt, overrides) => {
     const toolkit = overrides?.activeTools === undefined ? agent.toolkit : activeToolkit(overrides.activeTools);
-    const attempt = (activePrompt, retryOverflow) => Stream7.unwrap(Ref10.get(chat.history).pipe(Effect44.map((historyBeforeAttempt) => {
+    const attempt = (activePrompt, retryOverflow) => Stream6.unwrap(Ref10.get(chat.history).pipe(Effect44.map((historyBeforeAttempt) => {
       let emitted = false;
       const messages = Ai6.Prompt.concat(historyBeforeAttempt, activePrompt).content;
-      return chat.streamText({ prompt: activePrompt, toolkit, disableToolCallResolution: true }).pipe(Stream7.map((part) => ({ part, messages })), Stream7.tap(() => Effect44.sync(() => {
+      return chat.streamText({ prompt: activePrompt, toolkit, disableToolCallResolution: true }).pipe(Stream6.map((part) => ({ part, messages })), Stream6.tap(() => Effect44.sync(() => {
         emitted = true;
-      })), Stream7.catchCause((cause) => {
+      })), Stream6.catchCause((cause) => {
         if (Cause3.hasInterrupts(cause))
-          return Stream7.fromEffect(Effect44.interrupt);
+          return Stream6.fromEffect(Effect44.interrupt);
         const error = Cause3.squash(cause);
         if (retryOverflow && !emitted && isContextOverflow(error) && Option15.isSome(compactionService)) {
-          return Stream7.unwrap(Effect44.gen(function* () {
+          return Stream6.unwrap(Effect44.gen(function* () {
             yield* Ref10.set(chat.history, historyBeforeAttempt);
             const compactedPrompt = yield* preparePrompt(turn, activePrompt, true);
             return attempt(compactedPrompt, false);
           }));
         }
-        return Stream7.make({ part: Ai6.Response.makePart("error", { error }), messages });
+        return Stream6.make({ part: Ai6.Response.makePart("error", { error }), messages });
       }));
     })));
-    const parts = Stream7.unwrap(applyPromptChain(chain, Ai6.Prompt.make(prompt), { agentName: agent.name, turn }).pipe(Effect44.flatMap((transformedPrompt) => preparePrompt(turn, transformedPrompt, false)), Effect44.map((preparedPrompt) => attempt(preparedPrompt, true).pipe(Stream7.flatMap(({ part, messages }) => applyPartToEvents(turn, part, messages))))));
+    const parts = Stream6.unwrap(applyPromptChain(chain, Ai6.Prompt.make(prompt), { agentName: agent.name, turn }).pipe(Effect44.flatMap((transformedPrompt) => preparePrompt(turn, transformedPrompt, false)), Effect44.map((preparedPrompt) => attempt(preparedPrompt, true).pipe(Stream6.flatMap(({ part, messages }) => applyPartToEvents(turn, part, messages))))));
     const resilientParts = Option15.match(resilienceService, {
       onNone: () => parts,
-      onSome: (resilience) => Stream7.unwrap(Ai6.LanguageModel.LanguageModel.pipe(Effect44.map((model) => parts.pipe(Stream7.provideService(Ai6.LanguageModel.LanguageModel, apply(model, resilience))))))
+      onSome: (resilience) => Stream6.unwrap(Ai6.LanguageModel.LanguageModel.pipe(Effect44.map((model) => parts.pipe(Stream6.provideService(Ai6.LanguageModel.LanguageModel, apply(model, resilience))))))
     });
-    return overrides?.model === undefined ? resilientParts : resilientParts.pipe(Stream7.provide(overrides.model));
+    return overrides?.model === undefined ? resilientParts : resilientParts.pipe(Stream6.provide(overrides.model));
   };
   const turnCompletedEvent = (turn, transcript) => ({
     _tag: "TurnCompleted",
@@ -9579,7 +9597,7 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
     transcript,
     ...state.usage === undefined ? {} : { usage: state.usage }
   });
-  const structuredFinalEvents = (turn, config) => Stream7.fromEffect(Effect44.gen(function* () {
+  const structuredFinalEvents = (turn, config) => Stream6.fromEffect(Effect44.gen(function* () {
     const structuredTurn = turn + 1;
     const transformedPrompt = yield* applyPromptChain(chain, Ai6.Prompt.make(config.objectPrompt), {
       agentName: agent.name,
@@ -9601,7 +9619,7 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
       content: response.content
     };
     return [structuredOutput, terminalCompletedEvent(structuredTurn, transcript)];
-  })).pipe(Stream7.flatMap((events) => Stream7.fromIterable(events)));
+  })).pipe(Stream6.flatMap((events) => Stream6.fromIterable(events)));
   const promptFromSteeringMessages = (messages) => messages.reduce((prompt, message) => Ai6.Prompt.concat(prompt, message.prompt), Ai6.Prompt.empty);
   const takeSteering = () => Option15.match(steeringService, {
     onNone: () => Effect44.succeed([]),
@@ -9621,18 +9639,18 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
       const followUp = yield* takeFollowUp();
       if (followUp.length > 0) {
         return {
-          events: Stream7.fromIterable([completed]),
+          events: Stream6.fromIterable([completed]),
           next: { prompt: promptFromSteeringMessages(followUp) }
         };
       }
       if (structured !== undefined) {
         return {
-          events: Stream7.concat(Stream7.fromIterable([completed]), structuredFinalEvents(turn, structured))
+          events: Stream6.concat(Stream6.fromIterable([completed]), structuredFinalEvents(turn, structured))
         };
       }
       yield* savePersisted;
       return {
-        events: Stream7.fromIterable([completed, terminalCompletedEvent(turn, transcript)])
+        events: Stream6.fromIterable([completed, terminalCompletedEvent(turn, transcript)])
       };
     }
     const decision2 = yield* agent.policy.decide({
@@ -9642,7 +9660,7 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
     });
     if (decision2._tag === "Stop") {
       return {
-        events: Stream7.concat(Stream7.fromIterable([completed]), Stream7.fail(new TurnLimitExceeded({
+        events: Stream6.concat(Stream6.fromIterable([completed]), Stream6.fail(new TurnLimitExceeded({
           turn: turn + 1,
           pending: pending.map((result) => ({
             tool_call_id: result.id,
@@ -9657,21 +9675,21 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
     const basePrompt = steering.length === 0 ? toolPrompt : Ai6.Prompt.concat(promptFromSteeringMessages(steering), toolPrompt);
     const prompt = decision2.overrides?.instructions === undefined ? basePrompt : withSystem(decision2.overrides.instructions, basePrompt);
     return {
-      events: Stream7.fromIterable([completed]),
+      events: Stream6.fromIterable([completed]),
       next: { prompt, ...decision2.overrides === undefined ? {} : { overrides: decision2.overrides } }
     };
   });
-  const resetTurnState = (turn) => Stream7.sync(() => {
+  const resetTurnState = (turn) => Stream6.sync(() => {
     state.turn = turn;
     state.finish = undefined;
-  }).pipe(Stream7.drain);
+  }).pipe(Stream6.drain);
   const runTurn = (turn, prompt, overrides) => {
     let next;
-    const currentTurn = Stream7.fromIterable([{ _tag: "TurnStarted", turn }]).pipe(Stream7.concat(resetTurnState(turn)), Stream7.concat(modelTurn(turn, prompt, overrides)), Stream7.concat(Stream7.unwrap(afterTurn(turn).pipe(Effect44.map((result) => {
+    const currentTurn = Stream6.fromIterable([{ _tag: "TurnStarted", turn }]).pipe(Stream6.concat(resetTurnState(turn)), Stream6.concat(modelTurn(turn, prompt, overrides)), Stream6.concat(Stream6.unwrap(afterTurn(turn).pipe(Effect44.map((result) => {
       next = result.next;
       return result.events;
-    })))), Stream7.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": turn } }));
-    return Stream7.concat(currentTurn, Stream7.suspend(() => next === undefined ? Stream7.empty : runTurn(turn + 1, next.prompt, next.overrides)));
+    })))), Stream6.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": turn } }));
+    return Stream6.concat(currentTurn, Stream6.suspend(() => next === undefined ? Stream6.empty : runTurn(turn + 1, next.prompt, next.overrides)));
   };
   const resumeStream = (resume) => {
     let next;
@@ -9681,36 +9699,36 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect44.gen
       params: resume.call.params,
       providerExecuted: false
     });
-    const currentTurn = resetTurnState(0).pipe(Stream7.concat(Stream7.unwrap(Ref10.get(chat.history).pipe(Effect44.map((history) => toolCallEvents(0, call, history.content))))), Stream7.concat(Stream7.unwrap(afterTurn(0).pipe(Effect44.map((result) => {
+    const currentTurn = resetTurnState(0).pipe(Stream6.concat(Stream6.unwrap(Ref10.get(chat.history).pipe(Effect44.map((history) => toolCallEvents(0, call, history.content))))), Stream6.concat(Stream6.unwrap(afterTurn(0).pipe(Effect44.map((result) => {
       next = result.next;
       return result.events;
-    })))), Stream7.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": 0 } }));
-    return Stream7.concat(currentTurn, Stream7.suspend(() => next === undefined ? Stream7.empty : runTurn(1, next.prompt, next.overrides)));
+    })))), Stream6.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": 0 } }));
+    return Stream6.concat(currentTurn, Stream6.suspend(() => next === undefined ? Stream6.empty : runTurn(1, next.prompt, next.overrides)));
   };
   const baseInitialPrompt = seedSystem === undefined ? Ai6.Prompt.make(options.prompt) : withSystem(seedSystem, Ai6.Prompt.make(options.prompt));
   const initialPrompt = options.resume === undefined ? yield* recallInitialPrompt(baseInitialPrompt) : baseInitialPrompt;
   const runStream = options.resume === undefined ? runTurn(0, initialPrompt) : resumeStream(options.resume);
-  return runStream.pipe(Stream7.catchCause((cause) => {
+  return runStream.pipe(Stream6.catchCause((cause) => {
     if (Cause3.hasInterrupts(cause))
-      return Stream7.fromEffect(Effect44.interrupt);
+      return Stream6.fromEffect(Effect44.interrupt);
     const error = Cause3.squash(cause);
     if (error instanceof AgentSuspended) {
-      return Stream7.unwrap(Ref10.get(chat.history).pipe(Effect44.map((transcript) => Stream7.concat(Stream7.fromIterable([turnCompletedEvent(state.turn, transcript)]), Stream7.failCause(cause)))));
+      return Stream6.unwrap(Ref10.get(chat.history).pipe(Effect44.map((transcript) => Stream6.concat(Stream6.fromIterable([turnCompletedEvent(state.turn, transcript)]), Stream6.failCause(cause)))));
     }
-    return Stream7.failCause(cause);
+    return Stream6.failCause(cause);
   }));
-})).pipe(Stream7.withSpan("Baton.Agent.run", { attributes: { "baton.agent.name": agent.name } }));
+})).pipe(Stream6.withSpan("Baton.Agent.run", { attributes: { "baton.agent.name": agent.name } }));
 var stream2 = (agent, options) => streamInternal(agent, options, undefined);
 var streamObject = (agent, options) => streamInternal(agent, options, {
   schema: options.schema,
   objectName: options.objectName ?? "output",
   objectPrompt: options.objectPrompt ?? defaultObjectPrompt
 });
-var generate = (agent, options) => Stream7.runLast(stream2(agent, options)).pipe(Effect44.flatMap(Option15.match({
+var generate = (agent, options) => Stream6.runLast(stream2(agent, options)).pipe(Effect44.flatMap(Option15.match({
   onNone: () => Effect44.fail(new AgentError({ message: "Agent run ended without a Completed event", turn: 0 })),
   onSome: (event) => event._tag === "Completed" ? Effect44.succeed({ text: event.text, turns: event.turns, transcript: event.transcript }) : Effect44.fail(new AgentError({ message: "Agent run ended without a Completed event", turn: 0 }))
 })));
-var generateObject = (agent, options) => Stream7.runFold(streamObject(agent, options), () => ({
+var generateObject = (agent, options) => Stream6.runFold(streamObject(agent, options), () => ({
   value: Option15.none(),
   completed: Option15.none()
 }), (acc, event) => {
@@ -9891,8 +9909,8 @@ var selectListings = (skills, budgetTokens, recentlyUsed) => {
   return selected;
 };
 // ../runtime/src/agent/agent-loop-service.ts
-import { Config as Config3, Context as Context54, Crypto as Crypto3, Effect as Effect67, HashSet as HashSet6, Layer as Layer60, Option as Option22, Ref as Ref18, Schema as Schema60, Stream as Stream8 } from "effect";
-import * as Ai17 from "effect/unstable/ai";
+import { Config as Config3, Context as Context54, Crypto as Crypto3, Effect as Effect67, HashSet as HashSet6, Layer as Layer60, Option as Option22, Ref as Ref18, Schema as Schema60, Stream as Stream7 } from "effect";
+import * as Ai16 from "effect/unstable/ai";
 
 // ../runtime/src/child/child-run-service.ts
 var exports_child_run_service = {};
@@ -10217,7 +10235,6 @@ var spawnDynamic = Effect51.fn("ChildRunService.spawnDynamic.call")(function* (i
 
 // ../runtime/src/child/spawn-child-run-tool.ts
 import { Effect as Effect52, Schema as Schema50 } from "effect";
-import * as Ai11 from "effect/unstable/ai";
 var toolName = "spawn_child_run";
 var permissionName = "relay.child_run.spawn";
 var Input = Schema50.Struct({
@@ -10238,12 +10255,6 @@ var Output = Schema50.Struct({
 var TransferInput = Schema50.Struct({
   input: Schema50.optionalKey(Schema50.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.TransferInput" });
-var aiTool = Ai11.Tool.dynamic(toolName, {
-  description: "Spawn a durable child run and wait for its terminal output.",
-  parameters: Input,
-  success: Output
-});
-var jsonValue2 = (value) => Schema50.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var enabled = (agent) => agent.metadata?.multi_agent_enabled === true;
 var parentContext = (agent) => ({
   ...agent.instructions === undefined ? {} : { instructions: agent.instructions },
@@ -10337,7 +10348,7 @@ var dispatchChild = Effect52.fn("SpawnChildRunTool.dispatchChild")(function* (co
     eventSequence: 0,
     startedAt: (input.created_at ?? 0) + 2,
     completedAt: (input.created_at ?? 0) + 2,
-    agentDefinitionId: config.agentDefinitionId,
+    agentId: config.agentId,
     agentDefinitionRevision: config.agentDefinitionRevision,
     agentDefinitionSnapshot: definition,
     ...config.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: config.agentDefinitionToolInputSchemaDigests },
@@ -10362,11 +10373,10 @@ var resultFromTerminal = Effect52.fn("SpawnChildRunTool.resultFromTerminal")(fun
   const status = yield* childStatus(wait);
   const event = yield* terminalEvent(config.eventLog, wait.executionId, id2);
   const output = event?.content ?? [];
-  return jsonValue2({ child_execution_id: id2, status, output });
+  return { child_execution_id: id2, status, output };
 });
-var run2 = (config, activeToolName = toolName, fixedPresetName) => Effect52.fn("SpawnChildRunTool.run")(function* (rawInput, context) {
-  const input = fixedPresetName === undefined ? yield* Schema50.decodeUnknownEffect(Input)(rawInput).pipe(Effect52.mapError((error) => new ToolExecutionFailed({ tool_name: activeToolName, message: error.message }))) : yield* Schema50.decodeUnknownEffect(TransferInput)(rawInput).pipe(Effect52.map((transfer) => ({ preset_name: fixedPresetName, input: transfer.input ?? [] })), Effect52.mapError((error) => new ToolExecutionFailed({ tool_name: activeToolName, message: error.message })));
-  if (fixedPresetName === undefined)
+var run2 = Effect52.fn("SpawnChildRunTool.run")(function* (config, activeToolName, input, context, enforceStaticOrDynamic) {
+  if (enforceStaticOrDynamic)
     yield* ensureStaticOrDynamic(input);
   const id2 = childExecutionId(context);
   const waitId = childWaitId(id2);
@@ -10406,44 +10416,36 @@ var run2 = (config, activeToolName = toolName, fixedPresetName) => Effect52.fn("
   yield* dispatchChild(config, spawn, id2, definition, waitId);
   return yield* Effect52.fail(new ToolExecutionWaitRequested({ tool_name: activeToolName, wait_id: waitId }));
 });
-var registeredTool = (config) => ({
-  definition: {
-    ...definitionFromAiTool(aiTool, [{ name: permissionName, value: true }]),
-    metadata: { relay_core_tool: true }
-  },
-  aiTool,
+var registeredTool = (config) => tool(toolName, {
+  description: "Spawn a durable child run and wait for its terminal output.",
+  input: Input,
+  output: Output,
+  permissions: [{ name: permissionName, value: true }],
   requiredPermissions: [permissionName],
-  inputSchema: Input,
-  run: run2(config)
+  metadata: { relay_core_tool: true },
+  run: (input, context) => run2(config, toolName, input, context, true)
 });
 var transferToolName2 = (name) => `transfer_to_${name.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "")}`;
-var transferAiTool = (name) => Ai11.Tool.dynamic(name, {
-  description: "Transfer to a durable child run preset and wait for its terminal output.",
-  parameters: TransferInput,
-  success: Output
-});
 var transferTools = (config) => (config.agent.handoff_targets ?? []).map((target) => {
   const name = transferToolName2(target.name);
-  const tool = transferAiTool(name);
-  return {
-    definition: {
-      ...definitionFromAiTool(tool, [{ name: permissionName, value: true }]),
-      metadata: { relay_core_tool: true, handoff_target: target.name, preset_name: target.preset_name }
-    },
-    aiTool: tool,
+  return tool(name, {
+    description: "Transfer to a durable child run preset and wait for its terminal output.",
+    input: TransferInput,
+    output: Output,
+    permissions: [{ name: permissionName, value: true }],
     requiredPermissions: [permissionName],
-    inputSchema: TransferInput,
-    run: run2(config, name, target.preset_name)
-  };
+    metadata: { relay_core_tool: true, handoff_target: target.name, preset_name: target.preset_name },
+    run: (input, context) => run2(config, name, { preset_name: target.preset_name, input: input.input ?? [] }, context, false)
+  });
 });
 
 // ../runtime/src/memory/memory-service.ts
 import { Clock as Clock3, Context as Context46, Effect as Effect54, Layer as Layer47, Schema as Schema52 } from "effect";
-import * as Ai13 from "effect/unstable/ai";
+import * as Ai12 from "effect/unstable/ai";
 
 // ../runtime/src/model/embedding-model-service.ts
 import { Context as Context45, Effect as Effect53, Layer as Layer46, Ref as Ref13, Schema as Schema51 } from "effect";
-import * as Ai12 from "effect/unstable/ai";
+import * as Ai11 from "effect/unstable/ai";
 
 class EmbeddingModelNotRegistered extends Schema51.TaggedErrorClass()("EmbeddingModelNotRegistered", {
   provider: Schema51.String,
@@ -10482,7 +10484,7 @@ var resolveDefault = (registrations2, options) => {
   }
   return registrations2.length === 1 ? registrations2[0] : undefined;
 };
-var registrationFromLayer2 = (input) => Ai12.Model.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect53.map((layer33) => toRegistration({
+var registrationFromLayer2 = (input) => Ai11.Model.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect53.map((layer33) => toRegistration({
   provider: input.provider,
   model: input.model,
   ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
@@ -10540,12 +10542,12 @@ var deterministicVector = (input, dimensions) => {
 };
 var deterministicLayer = (options = {}) => {
   const dimensions = options.dimensions ?? 64;
-  return Layer46.mergeAll(Layer46.effect(Ai12.EmbeddingModel.EmbeddingModel, Ai12.EmbeddingModel.make({
+  return Layer46.mergeAll(Layer46.effect(Ai11.EmbeddingModel.EmbeddingModel, Ai11.EmbeddingModel.make({
     embedMany: ({ inputs }) => Effect53.succeed({
       results: inputs.map((input) => deterministicVector(input, dimensions)),
       usage: { inputTokens: inputs.reduce((total, input) => total + words(input).length, 0) }
     })
-  })), Layer46.succeed(Ai12.EmbeddingModel.Dimensions, dimensions));
+  })), Layer46.succeed(Ai11.EmbeddingModel.Dimensions, dimensions));
 };
 var deterministicRegistration = (options = {}) => registrationFromLayer2({
   provider: options.provider ?? "test",
@@ -10575,7 +10577,7 @@ var memoryError = (error) => new exports_memory.MemoryError({
   message: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
 });
 var decodeSubject = (subject) => Schema52.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect54.mapError(memoryError));
-var textPart = (text3) => Ai13.Prompt.makePart("text", { text: text3 });
+var textPart = (text3) => Ai12.Prompt.makePart("text", { text: text3 });
 var textFromParts = (parts) => parts.filter((part) => part.type === "text").map((part) => part.text).join(`
 `).trim();
 var latestUserText = (prompt) => {
@@ -10638,7 +10640,7 @@ var hashText = (input) => {
 };
 var memoryId = (input, text3) => `memory:${input.key.agent}:${input.key.subject}:${input.turn}:${hashText(`${input.key.agent}\x00${input.key.subject}\x00${input.turn}\x00${text3}`)}`;
 var embed = (models, text3, options) => {
-  const program = Ai13.EmbeddingModel.EmbeddingModel.pipe(Effect54.flatMap((model) => model.embed(text3)));
+  const program = Ai12.EmbeddingModel.EmbeddingModel.pipe(Effect54.flatMap((model) => model.embed(text3)));
   return (options?.embeddingSelection === undefined ? models.provideDefault(program) : models.provide(options.embeddingSelection, program)).pipe(Effect54.mapError(memoryError));
 };
 var make6 = (options = {}) => Effect54.gen(function* () {
@@ -10769,11 +10771,11 @@ __export(exports_model_call_policy, {
   Service: () => Service35
 });
 import { Context as Context48, Duration as Duration3, Layer as Layer49, Schedule as Schedule3 } from "effect";
-import * as Ai14 from "effect/unstable/ai";
+import * as Ai13 from "effect/unstable/ai";
 
 class Service35 extends Context48.Service()("@relayfx/runtime/ModelCallPolicy") {
 }
-var isOutputValidationError = (error) => Ai14.AiError.isAiError(error) ? error.reason._tag === "InvalidOutputError" : Ai14.AiError.isAiErrorReason(error) && error._tag === "InvalidOutputError";
+var isOutputValidationError = (error) => Ai13.AiError.isAiError(error) ? error.reason._tag === "InvalidOutputError" : Ai13.AiError.isAiErrorReason(error) && error._tag === "InvalidOutputError";
 var defaultClassify2 = (error) => isOutputValidationError(error) ? "terminal" : exports_model_resilience.defaultClassify(error);
 var defaultSchedule = Schedule3.exponential(Duration3.seconds(1)).pipe(Schedule3.jittered, Schedule3.both(Schedule3.recurs(4)));
 var make7 = (input) => ({
@@ -11014,7 +11016,7 @@ __export(exports_prompt_assembler_service, {
   PromptAssemblerError: () => PromptAssemblerError
 });
 import { Context as Context53, Effect as Effect60, Layer as Layer54, Schema as Schema56 } from "effect";
-import * as Ai15 from "effect/unstable/ai";
+import * as Ai14 from "effect/unstable/ai";
 
 // ../runtime/src/content/artifact-store-service.ts
 var exports_artifact_store_service = {};
@@ -11081,25 +11083,25 @@ class PromptAssemblerError extends Schema56.TaggedErrorClass()("PromptAssemblerE
 
 class Service40 extends Context53.Service()("@relayfx/runtime/PromptAssembler") {
 }
-var jsonValue3 = (value) => Schema56.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
-var stringifyJson = (value) => JSON.stringify(jsonValue3(value));
+var jsonValue2 = (value) => Schema56.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var stringifyJson = (value) => JSON.stringify(jsonValue2(value));
 var contentToPromptPart = (part) => {
   const options = part.provider_options;
   switch (part.type) {
     case "text":
-      return Ai15.Prompt.makePart("text", { text: part.text, ...options === undefined ? {} : { options } });
+      return Ai14.Prompt.makePart("text", { text: part.text, ...options === undefined ? {} : { options } });
     case "structured":
-      return Ai15.Prompt.makePart("text", {
+      return Ai14.Prompt.makePart("text", {
         text: stringifyJson(part.value),
         ...options === undefined ? {} : { options }
       });
     case "tool-call":
-      return Ai15.Prompt.makePart("text", {
+      return Ai14.Prompt.makePart("text", {
         text: stringifyJson(part.call),
         ...options === undefined ? {} : { options }
       });
     case "tool-result":
-      return Ai15.Prompt.makePart("text", {
+      return Ai14.Prompt.makePart("text", {
         text: stringifyJson(part.result),
         ...options === undefined ? {} : { options }
       });
@@ -11109,7 +11111,7 @@ var toAssemblerError = (error) => new PromptAssemblerError({
   message: error.reason !== undefined ? `${error._tag}: ${error.reason}` : error.message !== undefined ? `${error._tag}: ${error.message}` : error._tag
 });
 var resolveBlobPart = (blobs, part) => blobs.resolve(part).pipe(Effect60.map((resolved) => [
-  Ai15.Prompt.makePart("file", {
+  Ai14.Prompt.makePart("file", {
     mediaType: resolved.mediaType,
     data: resolved._tag === "Bytes" ? resolved.bytes : resolved.url,
     ...resolved.fileName === undefined ? {} : { fileName: resolved.fileName },
@@ -11140,19 +11142,19 @@ var resolveContentPart = (blobs, artifacts, part) => {
       return Effect60.succeed([contentToPromptPart(part)]);
   }
 };
-var toolSummary = (tools) => tools.map((tool) => ({
-  name: tool.name,
-  description: tool.description,
-  permissions: tool.permissions.map((permission) => permission.name)
+var toolSummary = (tools) => tools.map((tool2) => ({
+  name: tool2.name,
+  description: tool2.description,
+  permissions: tool2.permissions.map((permission) => permission.name)
 }));
 var defaultSystem = (agent, tools) => [`Agent: ${agent.name}`, agent.instructions ?? "", `Available tools: ${stringifyJson(toolSummary(tools))}`].filter((segment) => segment.length > 0).join(`
 
 `);
 var defaultPrompt = (blobs, artifacts, input) => Effect60.forEach(input, (part) => resolveContentPart(blobs, artifacts, part), { concurrency: 1 }).pipe(Effect60.map((parts) => {
   const flat = parts.flat();
-  return Ai15.Prompt.fromMessages([
-    Ai15.Prompt.makeMessage("user", {
-      content: flat.length === 0 ? [Ai15.Prompt.makePart("text", { text: "" })] : flat
+  return Ai14.Prompt.fromMessages([
+    Ai14.Prompt.makeMessage("user", {
+      content: flat.length === 0 ? [Ai14.Prompt.makePart("text", { text: "" })] : flat
     })
   ]);
 }));
@@ -11226,14 +11228,14 @@ var layerFromEpoch = (epoch) => exports_instructions.layer(epoch.baseline.length
 
 // ../runtime/src/agent/relay-permissions.ts
 import { Clock as Clock6, Effect as Effect62, Equal as Equal2, Layer as Layer56, Option as Option19, Schema as Schema57 } from "effect";
-var jsonValue4 = (value) => Schema57.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
+var jsonValue3 = (value) => Schema57.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
 var waitIdForToolCall = (toolCallId) => exports_ids_schema.WaitId.make(`wait:permission:${toolCallId}`);
 var fallbackToolCallId = (request) => `${request.agentName}:${request.turn}:${request.tool}`;
 var tokenFor2 = (request) => waitIdForToolCall(request.toolCallId ?? fallbackToolCallId(request));
-var matchingRule2 = (rules, tool, params) => {
+var matchingRule2 = (rules, tool2, params) => {
   let matched;
   for (const rule of rules) {
-    if (exports_permissions.matches(rule.pattern, tool, params))
+    if (exports_permissions.matches(rule.pattern, tool2, params))
       matched = rule;
   }
   return matched;
@@ -11293,7 +11295,7 @@ var permissionRequestedEvent = (config, pending, waitId, sequence) => ({
     tool_call_id: pending.toolCallId ?? pending.token,
     tool_name: pending.tool,
     wait_id: waitId,
-    input: jsonValue4(pending.params),
+    input: jsonValue3(pending.params),
     agent_name: pending.agentName,
     scope: config.scope
   },
@@ -11359,7 +11361,7 @@ var createAsk = Effect62.fn("RelayPermissions.createAsk")(function* (config, pen
       kind: "tool-permission",
       tool_call_id: pending.toolCallId ?? pending.token,
       tool_name: pending.tool,
-      input: jsonValue4(pending.params),
+      input: jsonValue3(pending.params),
       agent_name: pending.agentName,
       scope: config.scope
     },
@@ -11409,9 +11411,9 @@ var layer40 = (config) => Layer56.mergeAll(Layer56.succeed(exports_permissions.P
 
 // ../runtime/src/agent/relay-steering.ts
 import { Clock as Clock7, Effect as Effect63, Layer as Layer57, Schema as Schema58 } from "effect";
-import * as Ai16 from "effect/unstable/ai";
-var jsonValue5 = (value) => Schema58.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
-var stringifyJson2 = (value) => JSON.stringify(jsonValue5(value));
+import * as Ai15 from "effect/unstable/ai";
+var jsonValue4 = (value) => Schema58.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var stringifyJson2 = (value) => JSON.stringify(jsonValue4(value));
 var createdAtForSequence2 = (config, sequence) => config.startedAt + sequence - config.eventSequence;
 var drainId = (config, kind, sequence) => `drain:${config.executionId}:steering:${kind}:sequence:${sequence}`;
 var purePromptPart = (part) => {
@@ -11428,22 +11430,22 @@ var purePromptPart = (part) => {
 };
 var contentToPromptPart2 = (part) => {
   const pure = purePromptPart(part);
-  return pure === undefined ? Ai16.Prompt.makePart("text", { text: stringifyJson2(part) }) : contentToPromptPart(pure);
+  return pure === undefined ? Ai15.Prompt.makePart("text", { text: stringifyJson2(part) }) : contentToPromptPart(pure);
 };
-var promptForContent = (content) => Ai16.Prompt.fromMessages([
-  Ai16.Prompt.makeMessage("user", {
-    content: content.length === 0 ? [Ai16.Prompt.makePart("text", { text: "" })] : content.map((part) => contentToPromptPart2(part))
+var promptForContent = (content) => Ai15.Prompt.fromMessages([
+  Ai15.Prompt.makeMessage("user", {
+    content: content.length === 0 ? [Ai15.Prompt.makePart("text", { text: "" })] : content.map((part) => contentToPromptPart2(part))
   })
 ]);
 var promptTextParts = (prompt) => prompt.content.flatMap((message) => typeof message.content === "string" ? [exports_content_schema.text(message.content)] : message.content.flatMap((part) => part.type === "text" ? [exports_content_schema.text(part.text)] : []));
 var contentFromMessage = (message) => {
   if (typeof message.prompt === "string")
     return [exports_content_schema.text(message.prompt)];
-  const prompt = Ai16.Prompt.make(message.prompt);
+  const prompt = Ai15.Prompt.make(message.prompt);
   const textParts = promptTextParts(prompt);
   if (textParts.length > 0)
     return textParts;
-  return [exports_content_schema.text(stringifyJson2(Schema58.encodeSync(Ai16.Prompt.Prompt)(prompt)))];
+  return [exports_content_schema.text(stringifyJson2(Schema58.encodeSync(Ai15.Prompt.Prompt)(prompt)))];
 };
 var steeringReceivedEvent = (config, kind, drain2, messages, sequence) => ({
   id: exports_ids_schema.EventId.make(`event:${drain2.drainId}:received`),
@@ -11489,7 +11491,7 @@ var layer41 = (config) => Layer57.succeed(exports_steering.Steering, exports_ste
 
 // ../runtime/src/agent/relay-tool-executor.ts
 import { Effect as Effect64, Layer as Layer58, Option as Option20, Schema as Schema59 } from "effect";
-var jsonValue6 = (value) => Schema59.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue5 = (value) => Schema59.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var errorDetail = (error) => {
   switch (error._tag) {
     case "ToolNotRegistered":
@@ -11514,7 +11516,7 @@ var hasRequestedEvent = (config, callId) => config.eventLog.findByCursor({
 var boundResult = (config, result) => {
   if (config.toolOutputMaxBytes === undefined)
     return Effect64.succeed(result);
-  return exports_tool_output.bound({ _tag: "Success", result: result.output, encodedResult: result.output }, { toolCallId: result.call_id, maxBytes: config.toolOutputMaxBytes }).pipe(Effect64.map((bounded) => ({ ...result, output: jsonValue6(bounded.encodedResult) })), Effect64.mapError((error) => new ToolRuntimeError({ message: error.message })));
+  return exports_tool_output.bound({ _tag: "Success", result: result.output, encodedResult: result.output }, { toolCallId: result.call_id, maxBytes: config.toolOutputMaxBytes }).pipe(Effect64.map((bounded) => ({ ...result, output: jsonValue5(bounded.encodedResult) })), Effect64.mapError((error) => new ToolRuntimeError({ message: error.message })));
 };
 var make10 = (config) => ({
   execute: (request) => Effect64.gen(function* () {
@@ -11522,7 +11524,7 @@ var make10 = (config) => ({
     const call = {
       id: exports_ids_schema.ToolCallId.make(request.call.id),
       name: request.call.name,
-      input: jsonValue6(request.call.params)
+      input: jsonValue5(request.call.params)
     };
     const resumed = config.resumedToolCallId === call.id;
     const existingRequest = resumed ? yield* hasRequestedEvent(config, call.id) : false;
@@ -11618,11 +11620,11 @@ class AgentLoopBudgetExceeded extends Schema60.TaggedErrorClass()("AgentLoopBudg
 
 class Service41 extends Context54.Service()("@relayfx/runtime/AgentLoop") {
 }
-var jsonValue7 = (value) => Schema60.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue6 = (value) => Schema60.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var toolNames = (agent) => HashSet6.fromIterable(agent.tool_names);
 var availableRegisteredTools = (agent, registered) => {
   const names = toolNames(agent);
-  return registered.filter((tool) => tool.definition.name !== toolName && HashSet6.has(names, tool.definition.name));
+  return registered.filter((tool2) => tool2.definition.name !== toolName && HashSet6.has(names, tool2.definition.name));
 };
 var strictToolSchemaDigestConfig = Config3.boolean("RELAY_AGENT_TOOL_SCHEMA_DIGEST_STRICT").pipe(Config3.withDefault(false));
 var validateToolInputSchemaDigests = Effect67.fn("AgentLoop.validateToolInputSchemaDigests")(function* (input, definitions2) {
@@ -11650,7 +11652,7 @@ var validateToolInputSchemaDigests = Effect67.fn("AgentLoop.validateToolInputSch
 var childRunCoreTools = (input, childRuns, eventLog, waits) => {
   if (!enabled(input.agent))
     return Effect67.succeed([]);
-  if (input.agentDefinitionId === undefined || input.agentDefinitionRevision === undefined || input.dispatchChildRun === undefined) {
+  if (input.agentId === undefined || input.agentDefinitionRevision === undefined || input.dispatchChildRun === undefined) {
     return Effect67.fail(new AgentLoopError({
       message: "spawn_child_run requires a pinned agent definition and child dispatcher",
       next_event_sequence: input.eventSequence + 1
@@ -11659,7 +11661,7 @@ var childRunCoreTools = (input, childRuns, eventLog, waits) => {
   return Effect67.succeed([
     registeredTool({
       agent: input.agent,
-      agentDefinitionId: input.agentDefinitionId,
+      agentId: input.agentId,
       agentDefinitionRevision: input.agentDefinitionRevision,
       ...input.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: input.agentDefinitionToolInputSchemaDigests },
       childRuns,
@@ -11669,7 +11671,7 @@ var childRunCoreTools = (input, childRuns, eventLog, waits) => {
     }),
     ...transferTools({
       agent: input.agent,
-      agentDefinitionId: input.agentDefinitionId,
+      agentId: input.agentId,
       agentDefinitionRevision: input.agentDefinitionRevision,
       ...input.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: input.agentDefinitionToolInputSchemaDigests },
       childRuns,
@@ -11801,17 +11803,26 @@ var runStructuredTurn = Effect67.fn("AgentLoop.runStructuredTurn")(function* (la
     schema: registration.schema,
     objectName: "output"
   })).pipe(Effect67.mapError((error) => error instanceof AgentLoopError ? error : loopError(error, sequence)));
-  return jsonValue7(response.value);
+  return jsonValue6(response.value);
 });
 var loopError = (error, nextEventSequence2) => new AgentLoopError({
   message: error instanceof Error ? `${error.name}: ${error.message}` : String(error),
   next_event_sequence: nextEventSequence2
 });
 var appendEvent = (eventLog, event, nextEventSequence2) => appendIdempotentTo(eventLog, event).pipe(Effect67.mapError((error) => loopError(error, nextEventSequence2)));
-var aiToolFromDefinition = (definition) => aiToolFromRegistered({ definition, run: () => Effect67.die("model-facing toolkit is not executed") });
-var toolkitFromRegistered = (registered) => Ai17.Toolkit.make(...registered.map(aiToolFromRegistered));
+var toolFromDefinition = (definition) => dynamicTool(definition.name, {
+  description: definition.description,
+  inputSchema: definition.input_schema,
+  outputSchema: definition.output_schema,
+  permissions: definition.permissions,
+  ...definition.requirements === undefined ? {} : { requirements: definition.requirements },
+  ...definition.needs_approval === undefined ? {} : { needsApproval: definition.needs_approval },
+  ...definition.metadata === undefined ? {} : { metadata: definition.metadata },
+  run: () => Effect67.die("model-facing toolkit is not executed")
+}).tool;
+var toolkitFromRegistered = (registered) => Ai16.Toolkit.make(...registered.map(toolFromRegistered));
 var persistTranscript = (chats, input, transcript) => Effect67.gen(function* () {
-  const chat = yield* Ai17.Chat.fromPrompt(transcript);
+  const chat = yield* Ai16.Chat.fromPrompt(transcript);
   const exportData = yield* chat.export.pipe(Effect67.mapError((error) => loopError(error, input.eventSequence + 1)));
   yield* chats.save({ executionId: input.executionId, exportData, updatedAt: input.completedAt }).pipe(Effect67.mapError((error) => loopError(error, input.eventSequence + 1)));
 });
@@ -11823,7 +11834,7 @@ var restoreHistory = Effect67.fn("AgentLoop.restoreHistory")(function* (chats, i
       next_event_sequence: input.eventSequence + 1
     }));
   }
-  const chat = yield* Ai17.Chat.fromExport(record2.exportData).pipe(Effect67.mapError((error) => loopError(error, input.eventSequence + 1)));
+  const chat = yield* Ai16.Chat.fromExport(record2.exportData).pipe(Effect67.mapError((error) => loopError(error, input.eventSequence + 1)));
   return yield* Ref18.get(chat.history);
 });
 var saveContextEpoch = Effect67.fn("AgentLoop.saveContextEpoch")(function* (epochs, input, epoch) {
@@ -11850,7 +11861,7 @@ var mapBatonRunError = (error, current2) => {
       tool_call: {
         id: exports_ids_schema.ToolCallId.make(error.tool_call_id),
         name: error.tool_name,
-        input: jsonValue7(error.tool_params)
+        input: jsonValue6(error.tool_params)
       },
       next_event_sequence: current2
     });
@@ -11887,9 +11898,9 @@ var terminalMemoryTranscript = (prompt, text3) => {
     return;
   if (promptHasAssistantText(prompt, text3))
     return prompt;
-  return Ai17.Prompt.fromMessages([
+  return Ai16.Prompt.fromMessages([
     ...prompt.content,
-    Ai17.Prompt.makeMessage("assistant", { content: [Ai17.Prompt.makePart("text", { text: text3 })] })
+    Ai16.Prompt.makeMessage("assistant", { content: [Ai16.Prompt.makePart("text", { text: text3 })] })
   ]);
 };
 var recallOnlyMemory = (memory) => exports_memory.Memory.of({
@@ -11936,7 +11947,7 @@ var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
   const permissionRules = yield* Effect67.serviceOption(exports_permission_rule_repository.Service);
   const steeringRepository = yield* Effect67.serviceOption(exports_steering_repository.Service);
   const waits = yield* Effect67.serviceOption(Service25);
-  const tokenizer = yield* Effect67.serviceOption(Ai17.Tokenizer.Tokenizer);
+  const tokenizer = yield* Effect67.serviceOption(Ai16.Tokenizer.Tokenizer);
   return Service41.of({
     run: Effect67.fn("AgentLoop.run")(function* (input) {
       const existing = yield* existingOutput(eventLog, input);
@@ -11948,12 +11959,12 @@ var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
         next_event_sequence: input.eventSequence + 1
       })) : yield* childRunCoreTools(input, childRuns.value, eventLog, waits.value);
       const registered = [...availableRegisteredTools(input.agent, yield* tools.registeredTools), ...coreTools];
-      const definitions2 = registered.map((tool) => tool.definition);
+      const definitions2 = registered.map((tool2) => tool2.definition);
       yield* validateToolInputSchemaDigests(input, definitions2);
       yield* appendEvent(eventLog, inputPreparedEvent(input, definitions2), input.eventSequence + 1);
       const toolOutputMaxBytes = yield* effectiveToolOutputMaxBytes(input);
       const compactionOptions = yield* effectiveCompactionOptions(input);
-      const runTokenizer = yield* Effect67.serviceOption(Ai17.Tokenizer.Tokenizer);
+      const runTokenizer = yield* Effect67.serviceOption(Ai16.Tokenizer.Tokenizer);
       const activeTokenizer = Option22.isSome(runTokenizer) ? runTokenizer : tokenizer;
       const allocator = yield* make12(input.eventSequence + 1);
       const toolkit = toolkitFromRegistered(registered);
@@ -12132,13 +12143,13 @@ var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
         }
       });
       const runFold = Effect67.gen(function* () {
-        const base = yield* Ai17.LanguageModel.LanguageModel;
+        const base = yield* Ai16.LanguageModel.LanguageModel;
         const sessionStore = input.sessionId !== undefined && Option22.isSome(sessionRepository) ? yield* make8(input.sessionId, input.sessionEntryScope ?? input.executionId).pipe(Effect67.provideService(exports_session_repository.Service, sessionRepository.value)) : undefined;
-        const folded = exports_agent.stream(agent, batonOptions).pipe(Stream8.runFoldEffect(() => ({ text: "", transcript: undefined, turn: undefined, tokensUsed: seededTokens }), foldEvent), Effect67.provideService(Ai17.LanguageModel.LanguageModel, base), Effect67.provideService(exports_model_resilience.ModelResilience, policy), Effect67.provide(executorLayer), Effect67.provide(layer39), Effect67.provide(exports_model_middleware.identityLayer), Effect67.provide(instructionsLayer), Effect67.provide(permissionsLayer), Effect67.provide(steeringLayer));
+        const folded = exports_agent.stream(agent, batonOptions).pipe(Stream7.runFoldEffect(() => ({ text: "", transcript: undefined, turn: undefined, tokensUsed: seededTokens }), foldEvent), Effect67.provideService(Ai16.LanguageModel.LanguageModel, base), Effect67.provideService(exports_model_resilience.ModelResilience, policy), Effect67.provide(executorLayer), Effect67.provide(layer39), Effect67.provide(exports_model_middleware.identityLayer), Effect67.provide(instructionsLayer), Effect67.provide(permissionsLayer), Effect67.provide(steeringLayer));
         const withToolOutput = toolOutputStore === undefined ? folded : folded.pipe(Effect67.provideService(exports_tool_output.ToolOutputStore, toolOutputStore));
         const withCompaction = compactionService === undefined ? withToolOutput : withToolOutput.pipe(Effect67.provideService(exports_compaction.Compaction, compactionService));
         const withSession = sessionStore === undefined ? withCompaction : withCompaction.pipe(Effect67.provideService(exports_session.SessionStore, sessionStore));
-        const withTokenizer = Option22.isNone(activeTokenizer) ? withSession : withSession.pipe(Effect67.provideService(Ai17.Tokenizer.Tokenizer, activeTokenizer.value));
+        const withTokenizer = Option22.isNone(activeTokenizer) ? withSession : withSession.pipe(Effect67.provideService(Ai16.Tokenizer.Tokenizer, activeTokenizer.value));
         return yield* memory !== undefined && Option22.isSome(durableMemory) ? withTokenizer.pipe(Effect67.provideService(exports_memory.Memory, recallOnlyMemory(durableMemory.value))) : withTokenizer;
       });
       const finalState = yield* languageModels.provideForAgent(input.agent, runFold).pipe(Effect67.catch((error) => allocator.current.pipe(Effect67.flatMap((current2) => Effect67.fail(mapBoundaryError(error, current2))))));
@@ -12150,7 +12161,7 @@ var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
         }
       }
       const schemaRef = input.agent.output_schema_ref;
-      const structuredOutput = schemaRef === undefined || finalState.transcript === undefined ? undefined : yield* Ai17.Chat.fromPrompt(finalState.transcript).pipe(Effect67.flatMap((chat) => runStructuredTurn(languageModels, schemas, chat, input, schemaRef, completedSequence + 1)));
+      const structuredOutput = schemaRef === undefined || finalState.transcript === undefined ? undefined : yield* Ai16.Chat.fromPrompt(finalState.transcript).pipe(Effect67.flatMap((chat) => runStructuredTurn(languageModels, schemas, chat, input, schemaRef, completedSequence + 1)));
       const structuredPart = structuredOutput === undefined || schemaRef === undefined ? [] : [{ type: "structured", value: structuredOutput, schema_ref: schemaRef }];
       yield* appendEvent(eventLog, outputCompletedEvent(input, [...completedContent(finalState.text), ...structuredPart], finalState.text, completedSequence, structuredOutput), completedSequence + 1);
       return {
@@ -12362,8 +12373,8 @@ var validateDefinition2 = Effect69.fn("SkillRegistry.validateDefinition")(functi
   yield* requireOptionalText2(definition.frontmatter.agent, "definition.frontmatter.agent");
   yield* requireOptionalText2(definition.frontmatter.model, "definition.frontmatter.model");
   yield* requireText2(definition.body, "definition.body");
-  for (const tool of definition.frontmatter.allowed_tools ?? []) {
-    yield* requireText2(tool, "definition.frontmatter.allowed_tools[]");
+  for (const tool2 of definition.frontmatter.allowed_tools ?? []) {
+    yield* requireText2(tool2, "definition.frontmatter.allowed_tools[]");
   }
   for (const path2 of definition.frontmatter.paths ?? []) {
     yield* requireText2(path2, "definition.frontmatter.paths[]");
@@ -12495,7 +12506,7 @@ __export(exports_execution_service, {
   Service: () => Service44,
   ExecutionServiceError: () => ExecutionServiceError
 });
-import { Clock as Clock9, Context as Context57, Effect as Effect70, Layer as Layer63, Option as Option24, Schema as Schema63, Stream as Stream9 } from "effect";
+import { Clock as Clock9, Context as Context57, Effect as Effect70, Layer as Layer63, Option as Option24, Schema as Schema63, Stream as Stream8 } from "effect";
 import { ShardingConfig } from "effect/unstable/cluster";
 class ExecutionServiceError extends Schema63.TaggedErrorClass()("ExecutionServiceError", {
   message: Schema63.String,
@@ -12510,7 +12521,7 @@ var toExecution = (record2) => ({
   root_address_id: record2.rootAddressId,
   ...record2.sessionId === undefined ? {} : { session_id: record2.sessionId },
   status: record2.status,
-  ...record2.agentDefinitionId === undefined ? {} : { agent_definition_id: record2.agentDefinitionId },
+  ...record2.agentId === undefined ? {} : { agent_definition_id: record2.agentId },
   ...record2.agentDefinitionRevision === undefined ? {} : { agent_definition_revision: record2.agentDefinitionRevision },
   ...record2.agentDefinitionSnapshot === undefined ? {} : { agent_definition_snapshot: record2.agentDefinitionSnapshot },
   ...record2.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agent_definition_tool_input_schema_digests: record2.agentDefinitionToolInputSchemaDigests },
@@ -12524,7 +12535,7 @@ var mapChildRunError2 = (error) => new ExecutionServiceError({ message: error._t
 var childExecutionId2 = (input) => input.child_execution_id ?? exports_ids_schema.ChildExecutionId.make(`${input.execution_id}:child:${input.address_id}`);
 var hasCompleteAgentDefinitionPin2 = (input) => {
   const present = [
-    input.agentDefinitionId !== undefined,
+    input.agentId !== undefined,
     input.agentDefinitionRevision !== undefined,
     input.agentDefinitionSnapshot !== undefined
   ];
@@ -12533,7 +12544,7 @@ var hasCompleteAgentDefinitionPin2 = (input) => {
 };
 var validateAcceptInput = (input) => !hasCompleteAgentDefinitionPin2(input) ? Effect70.fail(new ExecutionServiceError({
   message: "agent definition pin must include id, revision, and snapshot together"
-})) : input.agentDefinitionToolInputSchemaDigests !== undefined && input.agentDefinitionId === undefined ? Effect70.fail(new ExecutionServiceError({
+})) : input.agentDefinitionToolInputSchemaDigests !== undefined && input.agentId === undefined ? Effect70.fail(new ExecutionServiceError({
   message: "agent definition tool input schema digests require a complete agent definition pin"
 })) : Effect70.void;
 var childContext = (input) => ({
@@ -12595,7 +12606,7 @@ var acceptedEvent = (input) => ({
   data: {
     root_address_id: input.rootAddressId,
     ...input.sessionId === undefined ? {} : { session_id: input.sessionId },
-    ...input.agentDefinitionId === undefined ? {} : { agent_definition_id: input.agentDefinitionId },
+    ...input.agentId === undefined ? {} : { agent_definition_id: input.agentId },
     ...input.agentDefinitionRevision === undefined ? {} : { agent_definition_revision: input.agentDefinitionRevision },
     ...input.metadata === undefined ? {} : { metadata: input.metadata }
   },
@@ -12699,7 +12710,7 @@ var layer46 = Layer63.effect(Service44, Effect70.gen(function* () {
         ...input.sessionId === undefined ? {} : { sessionId: input.sessionId },
         status: "queued",
         createdAt: input.createdAt,
-        ...input.agentDefinitionId === undefined ? {} : { agentDefinitionId: input.agentDefinitionId },
+        ...input.agentId === undefined ? {} : { agentId: input.agentId },
         ...input.agentDefinitionRevision === undefined ? {} : { agentDefinitionRevision: input.agentDefinitionRevision },
         ...input.agentDefinitionSnapshot === undefined ? {} : { agentDefinitionSnapshot: input.agentDefinitionSnapshot },
         ...input.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: input.agentDefinitionToolInputSchemaDigests },
@@ -12791,7 +12802,7 @@ var layer46 = Layer63.effect(Service44, Effect70.gen(function* () {
         ...override === undefined ? {} : { override }
       }).pipe(Effect70.mapError(mapChildRunError2));
     }),
-    stream: (input) => eventLog.stream(input).pipe(Stream9.take(input.limit ?? 1000), Stream9.mapError((error) => mapEventLogError4(error)))
+    stream: (input) => eventLog.stream(input).pipe(Stream8.take(input.limit ?? 1000), Stream8.mapError((error) => mapEventLogError4(error)))
   });
 }));
 var memoryLayer32 = layer46.pipe(Layer63.provide(layer32), Layer63.provide(exports_execution_repository.memoryLayer), Layer63.provide(exports_session_repository.memoryLayer), Layer63.provide(exports_child_execution_repository.memoryLayer), Layer63.provide(memoryLayer21), Layer63.provide(ShardingConfig.layer({ runnerAddress: Option24.none() })));
@@ -12816,7 +12827,7 @@ var spawnChildRun = Effect70.fn("ExecutionService.spawnChildRun.call")(function*
   const service = yield* Service44;
   return yield* service.spawnChildRun(input);
 });
-var stream3 = (input) => Stream9.unwrap(Service44.pipe(Effect70.map((service) => service.stream(input))));
+var stream3 = (input) => Stream8.unwrap(Service44.pipe(Effect70.map((service) => service.stream(input))));
 
 // ../runtime/src/workspace/workspace-planner-service.ts
 import { Context as Context59, Effect as Effect72, HashSet as HashSet7, Layer as Layer65, Option as Option25, Schema as Schema65 } from "effect";
@@ -13062,7 +13073,7 @@ var StartInput = Schema66.Struct({
   event_sequence: exports_execution_schema.ExecutionEventSequence,
   started_at: exports_shared_schema.TimestampMillis,
   completed_at: exports_shared_schema.TimestampMillis,
-  agent_definition_id: Schema66.optionalKey(exports_ids_schema.AgentDefinitionId),
+  agent_definition_id: Schema66.optionalKey(exports_ids_schema.AgentId),
   agent_definition_revision: Schema66.optionalKey(exports_agent_schema.DefinitionRevision),
   agent_definition_snapshot: Schema66.optionalKey(exports_agent_schema.Definition),
   agent_definition_tool_input_schema_digests: Schema66.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
@@ -13227,7 +13238,7 @@ var acceptExecution = (input) => Activity.make({
       ...input.session_id === undefined ? {} : { sessionId: input.session_id },
       eventSequence: input.event_sequence,
       createdAt: input.started_at,
-      ...input.agent_definition_id === undefined ? {} : { agentDefinitionId: input.agent_definition_id },
+      ...input.agent_definition_id === undefined ? {} : { agentId: input.agent_definition_id },
       ...input.agent_definition_revision === undefined ? {} : { agentDefinitionRevision: input.agent_definition_revision },
       ...input.agent_definition_snapshot === undefined ? {} : { agentDefinitionSnapshot: input.agent_definition_snapshot },
       ...input.agent_definition_tool_input_schema_digests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: input.agent_definition_tool_input_schema_digests },
@@ -13504,7 +13515,7 @@ var completeExecution = (input, waitId, waitState, workspaceRuntimeLayer, turn,
         sessionEntryScope: sessionEntryScope(input, turn)
       },
       agent: input.agent_definition_snapshot,
-      ...input.agent_definition_id === undefined ? {} : { agentDefinitionId: input.agent_definition_id },
+      ...input.agent_definition_id === undefined ? {} : { agentId: input.agent_definition_id },
       ...input.agent_definition_revision === undefined ? {} : { agentDefinitionRevision: input.agent_definition_revision },
       ...input.agent_definition_tool_input_schema_digests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: input.agent_definition_tool_input_schema_digests },
       input: input.input ?? [],
@@ -13523,7 +13534,7 @@ var completeExecution = (input, waitId, waitState, workspaceRuntimeLayer, turn,
         event_sequence: child.eventSequence,
         started_at: child.startedAt,
         completed_at: child.completedAt,
-        agent_definition_id: child.agentDefinitionId,
+        agent_definition_id: child.agentId,
         agent_definition_revision: child.agentDefinitionRevision,
         agent_definition_snapshot: child.agentDefinitionSnapshot,
         ...child.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agent_definition_tool_input_schema_digests: child.agentDefinitionToolInputSchemaDigests },
@@ -14057,7 +14068,7 @@ __export(exports_runner_runtime_service, {
   DatabaseMode: () => DatabaseMode,
   ClusterConfigMismatch: () => ClusterConfigMismatch
 });
-import { Config as Config5, Context as Context62, Crypto as Crypto4, Duration as Duration5, Effect as Effect77, Layer as Layer69, Option as Option27, Schema as Schema70, Stream as Stream10 } from "effect";
+import { Config as Config5, Context as Context62, Crypto as Crypto4, Duration as Duration5, Effect as Effect77, Layer as Layer69, Option as Option27, Schema as Schema70, Stream as Stream9 } from "effect";
 import {
   ClusterWorkflowEngine,
   HttpRunner,
@@ -14075,7 +14086,7 @@ import { FetchHttpClient } from "effect/unstable/http";
 import * as SqlClient43 from "effect/unstable/sql/SqlClient";
 import { RpcSerialization } from "effect/unstable/rpc";
 import { WorkflowEngine } from "effect/unstable/workflow";
-import * as Ai18 from "effect/unstable/ai";
+import * as Ai17 from "effect/unstable/ai";
 
 // ../runtime/src/schedule/scheduler-service.ts
 var exports_scheduler_service = {};
@@ -14501,9 +14512,9 @@ var sqlClientCheckLayer = Layer69.effect(Service49, Effect77.gen(function* () {
   const checkDatabase = yield* databaseHealthCheck;
   return yield* makeClientService(dialect2, checkDatabase);
 }));
-var deterministicTestModelLayer = Layer69.effect(Ai18.LanguageModel.LanguageModel, Ai18.LanguageModel.make({
+var deterministicTestModelLayer = Layer69.effect(Ai17.LanguageModel.LanguageModel, Ai17.LanguageModel.make({
   generateText: () => Effect77.succeed([{ type: "text", text: "deterministic test response" }]),
-  streamText: () => Stream10.make({ type: "text-delta", id: "text", delta: "deterministic test response" })
+  streamText: () => Stream9.make({ type: "text-delta", id: "text", delta: "deterministic test response" })
 }));
 var testLanguageModelLayer = layerFromRegistrationEffects3([
   registrationFromLayer3({
@@ -14874,7 +14885,7 @@ var guard = Effect78.fn("ActivityVersionRegistry.guard")(function* (input) {
   }));
 });
 // src/client.ts
-import { Clock as Clock11, Context as Context63, Effect as Effect79, Layer as Layer70, Option as Option28, Schema as Schema72, SchemaGetter, SchemaIssue, Stream as Stream11 } from "effect";
+import { Clock as Clock11, Context as Context63, Effect as Effect79, Layer as Layer70, Option as Option28, Schema as Schema72, SchemaGetter, SchemaIssue, Stream as Stream10 } from "effect";
 import { EntityId, ShardId, Sharding as Sharding2, ShardingConfig as ShardingConfig3 } from "effect/unstable/cluster";
 
 class ClientError extends Schema72.TaggedErrorClass()("ClientError", {
@@ -14925,7 +14936,7 @@ var toConversationSummary = (record2) => ({
   ...record2.sessionId === undefined ? {} : { session_id: record2.sessionId },
   status: record2.status,
   kind: conversationKind(record2.metadata),
-  ...record2.agentDefinitionId === undefined ? {} : { agent_definition_id: record2.agentDefinitionId },
+  ...record2.agentId === undefined ? {} : { agent_definition_id: record2.agentId },
   metadata: record2.metadata,
   created_at: record2.createdAt,
   updated_at: record2.updatedAt
@@ -14935,7 +14946,7 @@ var toExecutionView = (record2) => ({
   root_address_id: record2.rootAddressId,
   ...record2.sessionId === undefined ? {} : { session_id: record2.sessionId },
   status: record2.status,
-  ...record2.agentDefinitionId === undefined ? {} : { agent_definition_id: record2.agentDefinitionId },
+  ...record2.agentId === undefined ? {} : { agent_definition_id: record2.agentId },
   ...record2.agentDefinitionRevision === undefined ? {} : { agent_definition_revision: record2.agentDefinitionRevision },
   ...record2.agentDefinitionSnapshot === undefined ? {} : { agent_definition_snapshot: record2.agentDefinitionSnapshot },
   ...record2.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agent_definition_tool_input_schema_digests: record2.agentDefinitionToolInputSchemaDigests },
@@ -14962,6 +14973,10 @@ var toSessionSummary = (record2) => ({
   updated_at: record2.updatedAt
 });
 var executionIdFromIdempotencyKey = (idempotencyKey) => exports_ids_schema.ExecutionId.make(`execution:${idempotencyKey}`);
+var agentIdFromSlug = (slug) => exports_ids_schema.AgentId.make(`agent:${slug}`);
+var addressIdFromSlug = (slug) => exports_ids_schema.AddressId.make(`address:${slug}`);
+var addressIdFromTarget = (target) => typeof target === "string" ? exports_ids_schema.AddressId.make(target) : target.address_id;
+var idempotencyKeyFromStart = (addressId, input, now) => input.idempotency_key ?? input.execution_id ?? `${addressId}:${now}`;
 var metadataWithIdempotencyKey = (metadata11, idempotencyKey) => ({
   ...metadata11,
   idempotency_key: idempotencyKey
@@ -15084,11 +15099,11 @@ var parentDefinitionPin = Effect79.fn("Client.parentDefinitionPin")(function* (e
   if (record2 === undefined) {
     return yield* new ClientError({ message: `Execution not found: ${executionId}` });
   }
-  if (record2.agentDefinitionId === undefined || record2.agentDefinitionRevision === undefined || record2.agentDefinitionSnapshot === undefined) {
+  if (record2.agentId === undefined || record2.agentDefinitionRevision === undefined || record2.agentDefinitionSnapshot === undefined) {
     return yield* new ClientError({ message: `Parent execution is not pinned to an agent definition: ${executionId}` });
   }
   return {
-    agentDefinitionId: record2.agentDefinitionId,
+    agentId: record2.agentId,
     agentDefinitionRevision: record2.agentDefinitionRevision,
     agentDefinitionSnapshot: record2.agentDefinitionSnapshot,
     ...record2.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: record2.agentDefinitionToolInputSchemaDigests }
@@ -15101,7 +15116,7 @@ var childStartInput = (input, accepted2, pin, definition, createdAt, parentWaitI
   event_sequence: 0,
   started_at: createdAt,
   completed_at: createdAt,
-  agent_definition_id: pin.agentDefinitionId,
+  agent_definition_id: pin.agentId,
   agent_definition_revision: pin.agentDefinitionRevision,
   agent_definition_snapshot: definition,
   ...pin.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agent_definition_tool_input_schema_digests: pin.agentDefinitionToolInputSchemaDigests },
@@ -15302,7 +15317,7 @@ var layerFromRuntime = Layer70.effect(Service50, Effect79.gen(function* () {
       executionId: input.execution_id,
       ...input.after_cursor === undefined ? {} : { afterCursor: input.after_cursor },
       ...input.limit === undefined ? {} : { limit: input.limit }
-    }).pipe(Stream11.mapError(toClientError)),
+    }).pipe(Stream10.mapError(toClientError)),
     wake: Effect79.fn("Client.runtime.wake")(function* (input) {
       return yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, input);
     }),
@@ -15420,6 +15435,19 @@ var registerAgent = Effect79.fn("Client.registerAgent.call")(function* (input) {
   const service = yield* Service50;
   return yield* service.registerAgent(input);
 });
+var agent = Effect79.fn("Client.agent.call")(function* (slug, input) {
+  const id2 = input.id ?? agentIdFromSlug(slug);
+  const address = input.address ?? addressIdFromSlug(slug);
+  const { id: _id, address: _address, name, permissions, ...definitionInput } = input;
+  const registered = yield* registerAgent({
+    ...definitionInput,
+    id: id2,
+    address,
+    name: name ?? slug,
+    permissions: permissions ?? []
+  });
+  return { id: id2, address_id: address, record: registered.record };
+});
 var getAgentDefinition = Effect79.fn("Client.getAgentDefinition.call")(function* (id2) {
   const service = yield* Service50;
   return yield* service.getAgentDefinition(id2);
@@ -15468,6 +15496,30 @@ var startExecutionByAgentDefinition = Effect79.fn("Client.startExecutionByAgentD
   const service = yield* Service50;
   return yield* service.startExecutionByAgentDefinition(input);
 });
+var start2 = Effect79.fn("Client.start.call")(function* (target, input = {}) {
+  const addressId = addressIdFromTarget(target);
+  const now = yield* Clock11.currentTimeMillis;
+  const startedAt = input.started_at ?? now;
+  const completedAt = input.completed_at ?? startedAt;
+  const idempotencyKey = idempotencyKeyFromStart(addressId, input, startedAt);
+  return yield* startExecutionByAddress({
+    address_id: addressId,
+    ...input.session_id === undefined ? {} : { session_id: input.session_id },
+    ...input.input === undefined ? {} : { input: input.input },
+    idempotency_key: idempotencyKey,
+    ...input.execution_id === undefined ? {} : { execution_id: input.execution_id },
+    ...input.event_sequence === undefined ? {} : { event_sequence: input.event_sequence },
+    started_at: startedAt,
+    completed_at: completedAt,
+    ...input.wait_id === undefined ? {} : { wait_id: input.wait_id },
+    ...input.metadata === undefined ? {} : { metadata: input.metadata }
+  });
+});
+var run5 = (target, input = {}) => Stream10.unwrap(start2(target, input).pipe(Effect79.map((started) => streamExecution({
+  execution_id: started.execution_id,
+  ...input.after_cursor === undefined ? {} : { after_cursor: input.after_cursor },
+  ...input.limit === undefined ? {} : { limit: input.limit }
+}))));
 var cancelExecution2 = Effect79.fn("Client.cancelExecution.call")(function* (input) {
   const service = yield* Service50;
   return yield* service.cancelExecution(input);
@@ -15512,7 +15564,7 @@ var send3 = Effect79.fn("Client.send.call")(function* (input) {
   const service = yield* Service50;
   return yield* service.send(input);
 });
-var streamExecution = (input) => Stream11.unwrap(Service50.pipe(Effect79.map((service) => service.streamExecution(input))));
+var streamExecution = (input) => Stream10.unwrap(Service50.pipe(Effect79.map((service) => service.streamExecution(input))));
 var wake2 = Effect79.fn("Client.wake.call")(function* (input) {
   const service = yield* Service50;
   return yield* service.wake(input);
@@ -15678,7 +15730,7 @@ var StartExecutionInput = Schema73.Struct({
   event_sequence: exports_execution_schema.ExecutionEventSequence,
   started_at: exports_shared_schema.TimestampMillis,
   completed_at: exports_shared_schema.TimestampMillis,
-  agent_definition_id: Schema73.optionalKey(exports_ids_schema.AgentDefinitionId),
+  agent_definition_id: Schema73.optionalKey(exports_ids_schema.AgentId),
   agent_definition_revision: Schema73.optionalKey(exports_agent_schema.DefinitionRevision),
   agent_definition_snapshot: Schema73.optionalKey(exports_agent_schema.Definition),
   agent_definition_tool_input_schema_digests: Schema73.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
@@ -15867,7 +15919,7 @@ var ConversationSummary = Schema73.Struct({
   session_id: Schema73.optionalKey(exports_ids_schema.SessionId),
   status: exports_execution_schema.ExecutionStatus,
   kind: ConversationKind,
-  agent_definition_id: Schema73.optionalKey(exports_ids_schema.AgentDefinitionId),
+  agent_definition_id: Schema73.optionalKey(exports_ids_schema.AgentId),
   metadata: exports_shared_schema.Metadata,
   created_at: exports_shared_schema.TimestampMillis,
   updated_at: exports_shared_schema.TimestampMillis
@@ -15969,8 +16021,8 @@ var anthropicClientLayerConfig = Anthropic.AnthropicClient.layerConfig;
 var withAnthropic = (options) => exports_model_registry.layerFromRegistrationEffects([anthropic(options)]).pipe(Layer72.provide(Anthropic.AnthropicClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer72.provide(FetchHttpClient2.layer));
 // ../../node_modules/.bun/@batonfx+providers@0.1.1/node_modules/@batonfx/providers/src/deterministic.ts
 import * as OpenAi2 from "@effect/ai-openai";
-import { Effect as Effect81, Layer as Layer74, Option as Option29, Stream as Stream12 } from "effect";
-import * as Ai19 from "effect/unstable/ai";
+import { Effect as Effect81, Layer as Layer74, Option as Option29, Stream as Stream11 } from "effect";
+import * as Ai18 from "effect/unstable/ai";
 import { FetchHttpClient as FetchHttpClient4 } from "effect/unstable/http";
 
 // ../../node_modules/.bun/@batonfx+providers@0.1.1/node_modules/@batonfx/providers/src/openai.ts
@@ -15991,9 +16043,9 @@ var openAiClientLayerConfig = OpenAi.OpenAiClient.layerConfig;
 var withOpenAi = (options) => exports_model_registry.layerFromRegistrationEffects([openAi(options)]).pipe(Layer73.provide(OpenAi.OpenAiClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer73.provide(FetchHttpClient3.layer));
 
 // ../../node_modules/.bun/@batonfx+providers@0.1.1/node_modules/@batonfx/providers/src/deterministic.ts
-var deterministicModelLayer = Layer74.effect(Ai19.LanguageModel.LanguageModel, Ai19.LanguageModel.make({
+var deterministicModelLayer = Layer74.effect(Ai18.LanguageModel.LanguageModel, Ai18.LanguageModel.make({
   generateText: () => Effect81.succeed([{ type: "text", text: "deterministic response" }]),
-  streamText: () => Stream12.make(Ai19.Response.makePart("text-delta", { id: "text", delta: "deterministic response" }))
+  streamText: () => Stream11.make(Ai18.Response.makePart("text-delta", { id: "text", delta: "deterministic response" }))
 }));
 var deterministicModel = (input = {}) => exports_model_registry.registrationFromLayer({
   provider: input.provider ?? "deterministic",