@maxanstey-meridian/tandem 0.1.5 → 0.2.0

package/README.md

@@ -5,7 +5,7 @@ agentic pipeline SDK running on .NET and Microsoft Agent Framework.
 
 ## Requirements
 
-- macOS on Apple silicon
+- macOS on Apple silicon or Linux x64
 - Node.js 22 or newer
 - .NET 10 runtime
 
@@ -15,8 +15,8 @@ agentic pipeline SDK running on .NET and Microsoft Agent Framework.
 npm install @maxanstey-meridian/tandem zod
 ```
 
-The package includes compiled JavaScript, TypeScript declarations, and the macOS Apple silicon
-bridge runtime. Installation does not compile the SDK or download a bridge.
+The package includes compiled JavaScript, TypeScript declarations, and bridge runtimes for
+macOS Apple silicon and Linux x64. Installation does not compile the SDK or download a bridge.
 
 ## Quick Start
 
@@ -77,8 +77,8 @@ npm pack
 ```
 
 `npm pack` and `npm publish` build fresh output before packaging. The npm package contains
-`dist`, including one copy of the vendored bridge in `dist/runtime`. Update `runtime` from
-a tested Tandem bridge build before releasing runtime changes.
+`dist`, including the vendored platform bridge bundles in `dist/runtime`. Update each runtime
+bundle from a tested Tandem bridge build before releasing runtime changes.
 
 ## Runtime-sized collections
 

package/dist/index.d.ts

@@ -30,8 +30,8 @@ declare class CallbackRegistry {
     #private;
     registerSync(callback: SyncCallback): string;
     registerAsync(callback: AsyncCallback): string;
-    invokeSync(id: string, state: string, input: string): string;
-    invokeAsync(id: string, state: string, input: string, signal: AbortSignal): Promise<string>;
+    /** Never throws: failures travel back to the bridge as an encoded `CallbackResult`. */
+    invoke(id: string, state: string, input: string, signal: AbortSignal): string | Promise<string>;
     dispose(): void;
 }
 interface Participant<TState> {
@@ -56,13 +56,14 @@ export interface Terminal<TState> extends Participant<TState> {
     readonly kind: "terminal";
 }
 type Node<TState> = Collection<TState> | Stage<TState> | Interaction<TState, unknown, unknown> | Agent<TState> | Parallel<TState> | Terminal<TState>;
-export declare function stage<TState>(definition: {
+type StageDefinition<TState> = {
     id: string;
     execute: (state: TState, context: {
         readonly signal: AbortSignal;
     }) => TState | Promise<TState>;
     persist?: boolean;
-}): Stage<TState>;
+};
+export declare function stage<TState>(definition: StageDefinition<TState>): Stage<TState>;
 declare const taskAgentBrand: unique symbol;
 export interface TaskAgentReference {
     readonly id: string;
@@ -252,12 +253,13 @@ type ParallelDefinition<TState, TBranches extends ParallelBranches<TState>> = {
 };
 export declare function parallel<TState>(): <const TBranches extends ParallelBranches<TState>>(definition: ParallelDefinition<TState, TBranches>) => Parallel<TState>;
 export declare function parallel<TState, const TBranches extends ParallelBranches<TState>>(definition: ParallelDefinition<TState, TBranches>): Parallel<TState>;
-export declare function output<TState>(definition: {
+type TerminalDefinition<TState> = {
     id: string;
     summary: (state: TState) => string;
     failed?: boolean;
     persist?: boolean;
-}): Terminal<TState>;
+};
+export declare function output<TState>(definition: TerminalDefinition<TState>): Terminal<TState>;
 export interface OrdinaryRoute<TState> {
     readonly from: Stage<TState> | Collection<TState> | Interaction<TState, unknown, unknown>;
     readonly to: Node<TState>;
@@ -342,60 +344,6 @@ export interface RunResult<TState> {
     readonly state: TState;
     readonly summary: string | null;
 }
-export type RunObservation = {
-    readonly visitId?: string | null;
-} & ({
-    readonly version: 1;
-    readonly kind: "stepStarted";
-    readonly stepId: string;
-} | {
-    readonly version: 1;
-    readonly kind: "stepCompleted";
-    readonly stepId: string;
-} | {
-    readonly version: 1;
-    readonly kind: "stepCancelled";
-    readonly stepId: string;
-} | {
-    readonly version: 1;
-    readonly kind: "stepFaulted";
-    readonly stepId: string;
-    readonly error: string;
-} | {
-    readonly version: 1;
-    readonly kind: "agentText";
-    readonly stepId: string;
-    readonly text: string;
-} | {
-    readonly version: 1;
-    readonly kind: "agentReasoning";
-    readonly stepId: string;
-    readonly text: string;
-} | {
-    readonly version: 1;
-    readonly kind: "agentModelSelected";
-    readonly stepId: string;
-    readonly modelId: string;
-} | {
-    readonly version: 1;
-    readonly kind: "agentUsage";
-    readonly stepId: string;
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-    readonly reasoningTokens: number;
-    readonly currentContextTokens: number;
-    readonly contextWindowTokens: number | null;
-} | {
-    readonly version: 1;
-    readonly kind: "structuredOutputRejected";
-    readonly stepId: string;
-    readonly attempt: number;
-    readonly problems: readonly {
-        readonly field: string;
-        readonly message: string;
-    }[];
-    readonly rawResponse: string;
-});
 export interface TerminalPresentationOptions {
     readonly truncatedToolNames?: readonly string[];
 }
@@ -411,18 +359,84 @@ export interface RunOptions {
         readonly signal: AbortSignal;
     }) => void | Promise<void>;
 }
-declare const acceptedKinds: readonly ["StructuredOutputAccepted", "CapabilityAccepted", "InteractionRequested", "InteractionAnswered", "StepCompleted"];
-type AcceptedKind = (typeof acceptedKinds)[number];
-export type AcceptedValue = {
-    [K in AcceptedKind]: {
-        readonly version: 1;
-        readonly kind: K;
-        readonly stepId: string;
-        readonly visitId?: string | null;
-        readonly valueType: string | null;
-        readonly payload: unknown | null;
-    };
-}[AcceptedKind];
+declare const runObservationSchema: z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"stepStarted">;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"stepCompleted">;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"stepCancelled">;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"stepFaulted">;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"agentText">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"agentReasoning">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"agentModelSelected">;
+    modelId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"agentUsage">;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    reasoningTokens: z.ZodNumber;
+    currentContextTokens: z.ZodNumber;
+    contextWindowTokens: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"structuredOutputRejected">;
+    attempt: z.ZodNumber;
+    problems: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        field: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>>>;
+    rawResponse: z.ZodString;
+}, z.core.$strict>], "kind">>;
+export type RunObservation = z.infer<typeof runObservationSchema>;
+declare const acceptedValueFields: z.ZodObject<{
+    kind: z.ZodEnum<{
+        StructuredOutputAccepted: "StructuredOutputAccepted";
+        CapabilityAccepted: "CapabilityAccepted";
+        InteractionRequested: "InteractionRequested";
+        InteractionAnswered: "InteractionAnswered";
+        StepCompleted: "StepCompleted";
+    }>;
+    stepId: z.ZodString;
+    visitId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    valueType: z.ZodNullable<z.ZodString>;
+    payload: z.ZodUnknown;
+}, z.core.$strict>;
+export type AcceptedValue = Readonly<{
+    version: 1;
+} & z.infer<typeof acceptedValueFields>>;
 export declare function inspectAccepted(options: {
     ledgerPath: string;
     runId: string;