@yolk-sdk/harness 0.1.0-canary.100

package/dist/outcome-constructors-internal.d.mts

@@ -0,0 +1,403 @@
+import { StopReceipt as StopReceipt$1 } from "./coordinator.mjs";
+import { StopDecision as StopDecision$1 } from "./driver.mjs";
+import { HitlMatch as HitlMatch$1, OverflowCompactionResult as OverflowCompactionResult$1 } from "./outcome.mjs";
+import { Data } from "effect";
+
+//#region src/outcome-constructors-internal.d.ts
+declare const OverflowCompactionResult: {
+  readonly Compacted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Compacted";
+    readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+  }, "_tag">;
+  readonly Skipped: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Skipped";
+  }, "_tag">;
+  readonly $is: <Tag extends "Compacted" | "Skipped">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Compacted";
+    readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Skipped";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Compacted: (args: {
+        readonly _tag: "Compacted";
+        readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+      }) => any;
+      readonly Skipped: (args: {
+        readonly _tag: "Skipped";
+      }) => any;
+    }>(cases: Cases): (value: OverflowCompactionResult$1) => import("effect/Unify").Unify<ReturnType<Cases["Compacted" | "Skipped"]>>;
+    <Cases extends {
+      readonly Compacted: (args: {
+        readonly _tag: "Compacted";
+        readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+      }) => any;
+      readonly Skipped: (args: {
+        readonly _tag: "Skipped";
+      }) => any;
+    }>(value: OverflowCompactionResult$1, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Compacted" | "Skipped"]>>;
+  };
+};
+declare const StepOutcome: {
+  readonly Compacted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Compacted";
+    readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+    readonly overflowCompactionAttempt: number;
+  }, "_tag">;
+  readonly Completed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Completed";
+    readonly needsContinuation: boolean;
+    readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+    readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+    readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+    readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+  }, "_tag">;
+  readonly Retry: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Retry";
+    readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+  }, "_tag">;
+  readonly Continue: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Continue";
+    readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+    readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+    readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+    readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+    readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+  }, "_tag">;
+  readonly RecoverFull: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "RecoverFull";
+    readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+  }, "_tag">;
+  readonly AwaitingInput: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "AwaitingInput";
+    readonly requests: ReadonlyArray<import("@yolk-sdk/agent/protocol").HitlRequest>;
+    readonly usage: import("@yolk-sdk/agent/protocol").AgentUsage;
+  }, "_tag">;
+  readonly $is: <Tag extends "Compacted" | "Completed" | "Retry" | "Continue" | "RecoverFull" | "AwaitingInput">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Compacted";
+    readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+    readonly overflowCompactionAttempt: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Completed";
+    readonly needsContinuation: boolean;
+    readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+    readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+    readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+    readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Retry";
+    readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Continue";
+    readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+    readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+    readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+    readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+    readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "RecoverFull";
+    readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "AwaitingInput";
+    readonly requests: ReadonlyArray<import("@yolk-sdk/agent/protocol").HitlRequest>;
+    readonly usage: import("@yolk-sdk/agent/protocol").AgentUsage;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Compacted: (args: {
+        readonly _tag: "Compacted";
+        readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+        readonly overflowCompactionAttempt: number;
+      }) => any;
+      readonly Completed: (args: {
+        readonly _tag: "Completed";
+        readonly needsContinuation: boolean;
+        readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+        readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+        readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+        readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+      }) => any;
+      readonly Retry: (args: {
+        readonly _tag: "Retry";
+        readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+      }) => any;
+      readonly Continue: (args: {
+        readonly _tag: "Continue";
+        readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+        readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+        readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+        readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+        readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+      }) => any;
+      readonly RecoverFull: (args: {
+        readonly _tag: "RecoverFull";
+        readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+      }) => any;
+      readonly AwaitingInput: (args: {
+        readonly _tag: "AwaitingInput";
+        readonly requests: ReadonlyArray<import("@yolk-sdk/agent/protocol").HitlRequest>;
+        readonly usage: import("@yolk-sdk/agent/protocol").AgentUsage;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "Compacted";
+      readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+      readonly overflowCompactionAttempt: number;
+    } | {
+      readonly _tag: "Completed";
+      readonly needsContinuation: boolean;
+      readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+      readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+      readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+      readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+    } | {
+      readonly _tag: "Retry";
+      readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+    } | {
+      readonly _tag: "Continue";
+      readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+      readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+      readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+      readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+      readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+    } | {
+      readonly _tag: "RecoverFull";
+      readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+    } | {
+      readonly _tag: "AwaitingInput";
+      readonly requests: ReadonlyArray<import("@yolk-sdk/agent/protocol").HitlRequest>;
+      readonly usage: import("@yolk-sdk/agent/protocol").AgentUsage;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Compacted" | "Completed" | "Retry" | "Continue" | "RecoverFull" | "AwaitingInput"]>>;
+    <Cases extends {
+      readonly Compacted: (args: {
+        readonly _tag: "Compacted";
+        readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+        readonly overflowCompactionAttempt: number;
+      }) => any;
+      readonly Completed: (args: {
+        readonly _tag: "Completed";
+        readonly needsContinuation: boolean;
+        readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+        readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+        readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+        readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+      }) => any;
+      readonly Retry: (args: {
+        readonly _tag: "Retry";
+        readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+      }) => any;
+      readonly Continue: (args: {
+        readonly _tag: "Continue";
+        readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+        readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+        readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+        readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+        readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+      }) => any;
+      readonly RecoverFull: (args: {
+        readonly _tag: "RecoverFull";
+        readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+      }) => any;
+      readonly AwaitingInput: (args: {
+        readonly _tag: "AwaitingInput";
+        readonly requests: ReadonlyArray<import("@yolk-sdk/agent/protocol").HitlRequest>;
+        readonly usage: import("@yolk-sdk/agent/protocol").AgentUsage;
+      }) => any;
+    }>(value: {
+      readonly _tag: "Compacted";
+      readonly messages: ReadonlyArray<import("@yolk-sdk/agent/protocol").AgentMessage>;
+      readonly overflowCompactionAttempt: number;
+    } | {
+      readonly _tag: "Completed";
+      readonly needsContinuation: boolean;
+      readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+      readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+      readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+      readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+    } | {
+      readonly _tag: "Retry";
+      readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+    } | {
+      readonly _tag: "Continue";
+      readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+      readonly assistantMessage: import("@yolk-sdk/agent/loop").ModelTurnResult["assistantMessage"];
+      readonly toolCalls: import("@yolk-sdk/agent/loop").ModelTurnResult["toolCalls"];
+      readonly usage: import("@yolk-sdk/agent/loop").ModelTurnResult["usage"];
+      readonly stopReason: import("@yolk-sdk/agent/loop").ModelTurnResult["stopReason"];
+    } | {
+      readonly _tag: "RecoverFull";
+      readonly error: import("@yolk-sdk/agent/loop").AgentLoopError;
+    } | {
+      readonly _tag: "AwaitingInput";
+      readonly requests: ReadonlyArray<import("@yolk-sdk/agent/protocol").HitlRequest>;
+      readonly usage: import("@yolk-sdk/agent/protocol").AgentUsage;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Compacted" | "Completed" | "Retry" | "Continue" | "RecoverFull" | "AwaitingInput"]>>;
+  };
+};
+declare const HitlMatch: {
+  readonly Match: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Match";
+    readonly requestId: string;
+  }, "_tag">;
+  readonly Mismatch: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Mismatch";
+  }, "_tag">;
+  readonly $is: <Tag extends "Match" | "Mismatch">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Match";
+    readonly requestId: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Mismatch";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Match: (args: {
+        readonly _tag: "Match";
+        readonly requestId: string;
+      }) => any;
+      readonly Mismatch: (args: {
+        readonly _tag: "Mismatch";
+      }) => any;
+    }>(cases: Cases): (value: HitlMatch$1) => import("effect/Unify").Unify<ReturnType<Cases["Match" | "Mismatch"]>>;
+    <Cases extends {
+      readonly Match: (args: {
+        readonly _tag: "Match";
+        readonly requestId: string;
+      }) => any;
+      readonly Mismatch: (args: {
+        readonly _tag: "Mismatch";
+      }) => any;
+    }>(value: HitlMatch$1, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Match" | "Mismatch"]>>;
+  };
+};
+declare const StopReceipt: {
+  readonly Interrupted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Interrupted";
+  }, "_tag">;
+  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Idle";
+  }, "_tag">;
+  readonly LiveStopping: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "LiveStopping";
+  }, "_tag">;
+  readonly Settling: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Settling";
+  }, "_tag">;
+  readonly $is: <Tag extends "Interrupted" | "Idle" | "LiveStopping" | "Settling">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Idle";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Interrupted";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "LiveStopping";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Settling";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Interrupted: (args: {
+        readonly _tag: "Interrupted";
+      }) => any;
+      readonly Idle: (args: {
+        readonly _tag: "Idle";
+      }) => any;
+      readonly LiveStopping: (args: {
+        readonly _tag: "LiveStopping";
+      }) => any;
+      readonly Settling: (args: {
+        readonly _tag: "Settling";
+      }) => any;
+    }>(cases: Cases): (value: StopReceipt$1) => import("effect/Unify").Unify<ReturnType<Cases["Interrupted" | "Idle" | "LiveStopping" | "Settling"]>>;
+    <Cases extends {
+      readonly Interrupted: (args: {
+        readonly _tag: "Interrupted";
+      }) => any;
+      readonly Idle: (args: {
+        readonly _tag: "Idle";
+      }) => any;
+      readonly LiveStopping: (args: {
+        readonly _tag: "LiveStopping";
+      }) => any;
+      readonly Settling: (args: {
+        readonly _tag: "Settling";
+      }) => any;
+    }>(value: StopReceipt$1, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Interrupted" | "Idle" | "LiveStopping" | "Settling"]>>;
+  };
+};
+declare const StopDecision: {
+  readonly Interrupted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Interrupted";
+  }, "_tag">;
+  readonly ParkCleared: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ParkCleared";
+  }, "_tag">;
+  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Idle";
+  }, "_tag">;
+  readonly $is: <Tag extends "Interrupted" | "ParkCleared" | "Idle">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Interrupted";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ParkCleared";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Idle";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Interrupted: (args: {
+        readonly _tag: "Interrupted";
+      }) => any;
+      readonly ParkCleared: (args: {
+        readonly _tag: "ParkCleared";
+      }) => any;
+      readonly Idle: (args: {
+        readonly _tag: "Idle";
+      }) => any;
+    }>(cases: Cases): (value: StopDecision$1) => import("effect/Unify").Unify<ReturnType<Cases["Interrupted" | "ParkCleared" | "Idle"]>>;
+    <Cases extends {
+      readonly Interrupted: (args: {
+        readonly _tag: "Interrupted";
+      }) => any;
+      readonly ParkCleared: (args: {
+        readonly _tag: "ParkCleared";
+      }) => any;
+      readonly Idle: (args: {
+        readonly _tag: "Idle";
+      }) => any;
+    }>(value: StopDecision$1, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Interrupted" | "ParkCleared" | "Idle"]>>;
+  };
+};
+//#endregion
+export { HitlMatch, OverflowCompactionResult, StepOutcome, StopDecision, StopReceipt };
+//# sourceMappingURL=outcome-constructors-internal.d.mts.map

package/dist/outcome-constructors-internal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome-constructors-internal.d.mts","names":[],"sources":["../src/outcome-constructors-internal.ts"],"mappings":";;;;;;cASa,wBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA,WAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA,SAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA,WAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA,YAAA;EAAA"}

package/dist/outcome-constructors-internal.mjs

@@ -0,0 +1,11 @@
+import { Data } from "effect";
+//#region src/outcome-constructors-internal.ts
+const OverflowCompactionResult = Data.taggedEnum();
+const StepOutcome = Data.taggedEnum();
+const HitlMatch = Data.taggedEnum();
+const StopReceipt = Data.taggedEnum();
+const StopDecision = Data.taggedEnum();
+//#endregion
+export { HitlMatch, OverflowCompactionResult, StepOutcome, StopDecision, StopReceipt };
+
+//# sourceMappingURL=outcome-constructors-internal.mjs.map

package/dist/outcome-constructors-internal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome-constructors-internal.mjs","names":[],"sources":["../src/outcome-constructors-internal.ts"],"sourcesContent":["import { Data } from 'effect'\nimport type { StopReceipt as StopReceiptType } from './coordinator.ts'\nimport type { StopDecision as StopDecisionType } from './driver.ts'\nimport type {\n  HitlMatch as HitlMatchType,\n  OverflowCompactionResult as OverflowCompactionResultType,\n  StepOutcome as StepOutcomeType\n} from './outcome.ts'\n\nexport const OverflowCompactionResult = Data.taggedEnum<OverflowCompactionResultType>()\n\nexport const StepOutcome = Data.taggedEnum<StepOutcomeType>()\n\nexport const HitlMatch = Data.taggedEnum<HitlMatchType>()\n\nexport const StopReceipt = Data.taggedEnum<StopReceiptType>()\n\nexport const StopDecision = Data.taggedEnum<StopDecisionType>()\n"],"mappings":";;AASA,MAAa,2BAA2B,KAAK,WAAyC;AAEtF,MAAa,cAAc,KAAK,WAA4B;AAE5D,MAAa,YAAY,KAAK,WAA0B;AAExD,MAAa,cAAc,KAAK,WAA4B;AAE5D,MAAa,eAAe,KAAK,WAA6B"}