@relayfx/sdk 0.7.2 → 0.7.4

package/dist/types/runtime/address/address-resolution-service.d.ts

@@ -87,7 +87,7 @@ export declare const LocalAgentTarget: Schema.Struct<{
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
         readonly tool_execution?: Schema.Struct.ReadonlySide<{
-            readonly concurrency: Schema.Finite;
+            readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
         }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;

package/dist/types/runtime/agent/agent-loop-events.d.ts

@@ -1,24 +1,35 @@
+import type { AgentEvent, ModelTelemetry } from "@batonfx/core";
 import { Content, Execution, Shared, Tool } from "../../schema/index";
 import type { Response } from "effect/unstable/ai";
 import type { RunInput } from "./agent-loop-service";
+declare const legacyTelemetryCursor: (input: RunInput, event: ModelTelemetry.Event) => string;
+declare const legacyUsageCursor: (input: RunInput, event: ModelTelemetry.ModelAttemptCompleted) => string;
+declare const telemetryEvent: (input: RunInput, sessionId: string, event: ModelTelemetry.Event, sequence: number, createdAt: number) => Execution.ExecutionEvent;
 declare const inputPreparedEvent: (input: RunInput, definitions: ReadonlyArray<Tool.Definition>) => Execution.ExecutionEvent;
-declare const usageReportedEvent: (input: RunInput, part: Response.FinishPart, modelSnapshot: string | undefined, sequence: Execution.ExecutionEventSequence) => Execution.ExecutionEvent;
+declare const usageReportedEvent: (input: RunInput, sessionId: string, event: ModelTelemetry.ModelAttemptCompleted, sequence: Execution.ExecutionEventSequence, createdAt: number) => Execution.ExecutionEvent;
 declare const budgetExceededEvent: (input: RunInput, tokensUsed: number, tokenBudget: number, sequence: Execution.ExecutionEventSequence) => Execution.ExecutionEvent;
-declare const outputDeltaEvent: (input: RunInput, part: Response.TextDeltaPart, deltaIndex: number) => Execution.ExecutionEvent;
-declare const reasoningDeltaEvent: (input: RunInput, part: Response.ReasoningPart | Response.ReasoningDeltaPart, deltaIndex: number) => Execution.ExecutionEvent;
-declare const toolCallDeltaEvent: (input: RunInput, part: Response.ToolParamsDeltaPart, toolCallName: string | undefined, sequence: Execution.ExecutionEventSequence, deltaIndex: number) => Execution.ExecutionEvent;
-declare const outputCompletedEvent: (input: RunInput, content: ReadonlyArray<Content.Part>, outputText: string, sequence: Execution.ExecutionEventSequence, structuredOutput?: Shared.JsonValue) => Execution.ExecutionEvent;
+declare const outputDeltaEvent: (input: RunInput, modelPart: AgentEvent.ModelPart, part: Response.TextDeltaPart, deltaIndex: number, createdAt: number) => Execution.ExecutionEvent;
+declare const reasoningDeltaEvent: (input: RunInput, modelPart: AgentEvent.ModelPart, part: Response.ReasoningPart | Response.ReasoningDeltaPart, deltaIndex: number, createdAt: number) => Execution.ExecutionEvent;
+declare const toolCallDeltaEvent: (input: RunInput, modelPart: AgentEvent.ModelPart, part: Response.ToolParamsDeltaPart, toolCallName: string | undefined, sequence: Execution.ExecutionEventSequence, deltaIndex: number, createdAt: number) => Execution.ExecutionEvent;
+declare const outputCompletedEvent: (input: RunInput, content: ReadonlyArray<Content.Part>, outputText: string, sequence: Execution.ExecutionEventSequence, structuredOutput?: Shared.JsonValue, structuredIdentity?: {
+    readonly modelCallId: string;
+    readonly modelAttemptId: string;
+    readonly attempt: number;
+}) => Execution.ExecutionEvent;
 declare const completedContent: (outputText: string) => ReadonlyArray<Content.Part>;
 declare const modelOutputMetadata: (event: Execution.ExecutionEvent) => Shared.Metadata;
 export declare const AgentLoopEvents: {
     budgetExceededEvent: typeof budgetExceededEvent;
     completedContent: typeof completedContent;
     inputPreparedEvent: typeof inputPreparedEvent;
+    legacyTelemetryCursor: typeof legacyTelemetryCursor;
+    legacyUsageCursor: typeof legacyUsageCursor;
     modelOutputMetadata: typeof modelOutputMetadata;
     outputCompletedEvent: typeof outputCompletedEvent;
     outputDeltaEvent: typeof outputDeltaEvent;
     reasoningDeltaEvent: typeof reasoningDeltaEvent;
     toolCallDeltaEvent: typeof toolCallDeltaEvent;
+    telemetryEvent: typeof telemetryEvent;
     usageReportedEvent: typeof usageReportedEvent;
 };
 export {};

package/dist/types/runtime/agent/agent-loop-service.d.ts

@@ -32,6 +32,7 @@ export declare class AgentLoopWaitRequested extends AgentLoopWaitRequested_base
 }
 export interface RunInput {
     readonly executionId: Ids.ExecutionId;
+    readonly origin?: Execution.ExecutionOrigin;
     readonly sessionId?: Ids.SessionId;
     readonly agent: Agent.Definition;
     readonly agentId?: Ids.AgentId;

package/dist/types/runtime/child/spawn-child-run-tool.d.ts

@@ -197,6 +197,7 @@ export interface TransferInput extends Schema.Schema.Type<typeof TransferInput>
 }
 export interface DispatchInput {
     readonly executionId: Ids.ExecutionId;
+    readonly origin?: Execution.ExecutionOrigin;
     readonly rootAddressId: Ids.AddressId;
     readonly sessionId: Ids.SessionId;
     readonly input: ReadonlyArray<Content.Part>;
@@ -211,6 +212,7 @@ export interface DispatchInput {
 }
 export interface Config {
     readonly agent: Agent.Definition;
+    readonly origin?: Execution.ExecutionOrigin;
     readonly agentId: Ids.AgentId;
     readonly agentRevision: Agent.DefinitionRevision;
     readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;

package/dist/types/runtime/workflow/execution-workflow.d.ts

@@ -121,7 +121,7 @@ export declare const StartInput: Schema.Struct<{
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
         readonly tool_execution?: Schema.Struct.ReadonlySide<{
-            readonly concurrency: Schema.Finite;
+            readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
         }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
@@ -199,6 +199,16 @@ export declare const StartInput: Schema.Struct<{
     }>;
     readonly resume_suspension: Schema.optionalKey<typeof AgentEvent.AgentSuspended>;
     readonly workflow_generation: Schema.optionalKey<Schema.Int>;
+    readonly origin: Schema.optionalKey<Schema.Struct<{
+        readonly owner_kind: Schema.Literals<readonly ["service", "user", "workflow", "system"]>;
+        readonly owner: Schema.String;
+        readonly purpose: Schema.String;
+        readonly build: Schema.optionalKey<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly version: Schema.optionalKey<Schema.String>;
+            readonly commit: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>;
 export interface StartInput extends Schema.Schema.Type<typeof StartInput> {
@@ -409,7 +419,7 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
         readonly tool_execution?: Schema.Struct.ReadonlySide<{
-            readonly concurrency: Schema.Finite;
+            readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
         }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
@@ -487,6 +497,16 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
     }>;
     readonly resume_suspension: Schema.optionalKey<typeof AgentEvent.AgentSuspended>;
     readonly workflow_generation: Schema.optionalKey<Schema.Int>;
+    readonly origin: Schema.optionalKey<Schema.Struct<{
+        readonly owner_kind: Schema.Literals<readonly ["service", "user", "workflow", "system"]>;
+        readonly owner: Schema.String;
+        readonly purpose: Schema.String;
+        readonly build: Schema.optionalKey<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly version: Schema.optionalKey<Schema.String>;
+            readonly commit: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>, Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {

package/dist/types/schema/agent-schema.d.ts

@@ -144,7 +144,7 @@ declare const DefinitionSchema: Schema.Struct<{
     }>>;
     readonly turn_policy: Schema.optionalKey<Schema.Codec<TurnPolicySnapshot, TurnPolicySnapshot, never, never>>;
     readonly tool_execution: Schema.optionalKey<Schema.Struct<{
-        readonly concurrency: Schema.Finite;
+        readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
     }>>;
     readonly compaction_policy: Schema.optionalKey<Schema.Struct<{
         readonly context_window: Schema.Finite;
@@ -217,7 +217,7 @@ export interface DefineInput {
     readonly permission_rules?: PermissionRuleset;
     readonly turn_policy?: TurnPolicySnapshot;
     readonly tool_execution?: {
-        readonly concurrency: number;
+        readonly concurrency: number | "unbounded";
     };
     readonly compaction_policy?: CompactionPolicy;
     readonly max_tool_turns?: number;
@@ -267,7 +267,7 @@ export declare const DefinitionRecord: Schema.Struct<{
         };
         readonly turn_policy?: TurnPolicySnapshot;
         readonly tool_execution?: Schema.Struct.ReadonlySide<{
-            readonly concurrency: Schema.Finite;
+            readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
         }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
@@ -383,7 +383,7 @@ export declare const DefinitionRevisionRecord: Schema.Struct<{
         };
         readonly turn_policy?: TurnPolicySnapshot;
         readonly tool_execution?: Schema.Struct.ReadonlySide<{
-            readonly concurrency: Schema.Finite;
+            readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
         }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
@@ -497,7 +497,7 @@ export declare const RegisterDefinitionPayload: Schema.Struct<{
         };
         readonly turn_policy?: TurnPolicySnapshot;
         readonly tool_execution?: Schema.Struct.ReadonlySide<{
-            readonly concurrency: Schema.Finite;
+            readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
         }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
@@ -611,7 +611,7 @@ export declare const DefinitionRegistered: Schema.Struct<{
             };
             readonly turn_policy?: TurnPolicySnapshot;
             readonly tool_execution?: Schema.Struct.ReadonlySide<{
-                readonly concurrency: Schema.Finite;
+                readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
             }, "Encoded">;
             readonly compaction_policy?: {
                 readonly context_window: number;
@@ -729,7 +729,7 @@ export declare const DefinitionList: Schema.Struct<{
             };
             readonly turn_policy?: TurnPolicySnapshot;
             readonly tool_execution?: Schema.Struct.ReadonlySide<{
-                readonly concurrency: Schema.Finite;
+                readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
             }, "Encoded">;
             readonly compaction_policy?: {
                 readonly context_window: number;
@@ -847,7 +847,7 @@ export declare const DefinitionRevisionList: Schema.Struct<{
             };
             readonly turn_policy?: TurnPolicySnapshot;
             readonly tool_execution?: Schema.Struct.ReadonlySide<{
-                readonly concurrency: Schema.Finite;
+                readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
             }, "Encoded">;
             readonly compaction_policy?: {
                 readonly context_window: number;