@boboddy/sdk 0.4.2 → 0.5.0

package/dist/step-execution-plane-client.d.ts

@@ -22,7 +22,7 @@ declare const buildStepExecutionPlaneClient: (stepExecutions: StepExecutions) =>
             projectId: string;
             stepDefinitionId: string;
             stepDefinitionVersion: number;
-            status: "queued" | "running" | "succeeded" | "failed" | "timeout" | "abandoned" | "cancelled" | "skipped";
+            status: "pending" | "queued" | "running" | "succeeded" | "failed" | "timeout" | "abandoned" | "cancelled" | "skipped";
             inputJson: unknown;
             claimedBy: string | unknown;
             claimedAt: string | unknown;
@@ -65,7 +65,7 @@ declare const buildStepExecutionPlaneClient: (stepExecutions: StepExecutions) =>
         projectId: string;
         stepDefinitionId: string;
         stepDefinitionVersion: number;
-        status: "queued" | "running" | "succeeded" | "failed" | "timeout" | "abandoned" | "cancelled" | "skipped";
+        status: "pending" | "queued" | "running" | "succeeded" | "failed" | "timeout" | "abandoned" | "cancelled" | "skipped";
         inputJson: unknown;
         claimedBy: string | unknown;
         claimedAt: string | unknown;
@@ -126,7 +126,7 @@ declare const buildStepExecutionPlaneClient: (stepExecutions: StepExecutions) =>
         };
         stepExecution: {
             id: string;
-            status: "queued" | "running" | "succeeded" | "failed" | "timeout" | "abandoned" | "cancelled" | "skipped";
+            status: "pending" | "queued" | "running" | "succeeded" | "failed" | "timeout" | "abandoned" | "cancelled" | "skipped";
             inputJson: unknown;
             executionTimeoutSeconds: number | unknown;
         };
@@ -134,7 +134,12 @@ declare const buildStepExecutionPlaneClient: (stepExecutions: StepExecutions) =>
             id: string;
             key: string;
             name: string;
-            prompt: string;
+            prompt: string | unknown;
+            kind: "built_in" | "user_defined" | "code";
+            entrypointJson: {
+                sourceFile: string;
+                exportName: string;
+            } | unknown;
             executionMode: "workspace" | "no_workspace";
             resultSchemaJson: {
                 [key: string]: unknown;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@boboddy/sdk",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "type": "module",
   "exports": {
     ".": {
@@ -83,7 +83,7 @@
   },
   "devDependencies": {
     "@hey-api/openapi-ts": "^0.90.10",
-    "bun-types": "^1.3.12",
+    "bun-types": "^1.4.0",
     "zod": "^4.3.6"
   }
 }

package/dist/definitions/pipelines/builder.d.ts

@@ -1,80 +0,0 @@
-import { z, type ZodType } from "zod";
-import { type AdvanceCtx, type AdvanceResult } from "../advancement-policies/fluent-rules";
-import { type AnyBinding, type PipelineDefinitionSpec, type PipelineNodeConfig } from "./define-pipeline";
-import { type AnyTypedStep, type IsAny, type LastSignalKeys, type OptionalInputKeys, type PipelineMeta, type RequiredInputKeys, type StepInputCtx } from "./builder-helpers";
-import { type FanOutStepConfig } from "./fan-out-builder";
-export type { AnyTypedStep, PipelineMeta, StepInputCtx, WorkItemAccessor, } from "./builder-helpers";
-export { type FanOutStepConfig, type FanOutInputMapping, } from "./fan-out-builder";
-type StepInputMapping<S extends AnyTypedStep> = IsAny<S["__inputType"]> extends true ? Partial<Record<string, AnyBinding>> : S["__inputType"] extends object ? {
-    [K in RequiredInputKeys<S["__inputType"]>]: AnyBinding;
-} & {
-    [K in OptionalInputKeys<S["__inputType"]>]?: AnyBinding;
-} : Partial<Record<string, AnyBinding>>;
-/**
- * `.step()`'s single options argument. Deliberately a single generic type
- * (not a set of overload signatures split on `S["__hasAdditionalInput"]`):
- * with overloads, a mistake inside `options.input`'s return value fails
- * every overload, and TS reports "no overload matches" against the whole
- * call rather than pointing at the specific missing/wrong property inside
- * `input`'s return type. A single signature lets TS check `options`
- * structurally in one pass and localize the error correctly.
- */
-type StepOptions<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>, TFanOuts extends ReadonlyArray<AnyTypedStep>, S extends AnyTypedStep> = (S extends {
-    __hasAdditionalInput: false;
-} ? {
-    input?: (ctx: StepInputCtx<TInput, TSteps, TFanOuts>) => Partial<Record<string, AnyBinding>>;
-} : {
-    input: (ctx: StepInputCtx<TInput, TSteps, TFanOuts>) => StepInputMapping<S>;
-}) & {
-    advance: (ctx: AdvanceCtx<S["__signalKeys"], S["__signalTypeMap"]>) => AdvanceResult<S["__signalKeys"]>;
-    timeout?: number | null;
-};
-/**
- * Returned by `.step()`/`pipeline()`. Provides `.step()` to chain the next
- * step, `.fanOutStep()` to begin a fan-out+cohort-gate pair (issue #167),
- * and `.build()` to finalize. `.step()` requires an `advance` callback in
- * its options — deciding how the pipeline continues past this step — as
- * part of the same call that declares the step's input, rather than as a
- * separate chained method on an intermediate builder class.
- */
-export declare class PipelineStepBuilder<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>, TFanOuts extends ReadonlyArray<AnyTypedStep> = []> {
-    protected readonly inputSchema: TInput;
-    protected readonly meta: Omit<PipelineMeta<TInput>, "additionalPipelineInput" | "additionalStepInput">;
-    protected readonly nodes: PipelineNodeConfig[];
-    protected readonly pipelineInputBindings: Record<string, AnyBinding>;
-    protected readonly pipelineStepInputBindings: Record<string, AnyBinding>;
-    readonly __steps: TSteps;
-    readonly __fanOuts: TFanOuts;
-    constructor(inputSchema: TInput, meta: Omit<PipelineMeta<TInput>, "additionalPipelineInput" | "additionalStepInput">, nodes: PipelineNodeConfig[], pipelineInputBindings?: Record<string, AnyBinding>, pipelineStepInputBindings?: Record<string, AnyBinding>);
-    step<S extends AnyTypedStep>(step: S, options: StepOptions<TInput, TSteps, TFanOuts, S>): PipelineStepBuilder<TInput, [...TSteps, S], TFanOuts>;
-    /**
-     * Begins a fan-out+cohort-gate pair (issue #167): `step` is the template
-     * every branch executes, with its branch count (and, when `over` names
-     * an array-typed signal, each branch's own typed `item`) resolved at
-     * runtime from `config.over` (a signal on the step immediately
-     * preceding this fan-out). `config` requires both `advance` (each
-     * branch's own continue/block decision) and `advanceAll` (the
-     * whole-cohort decision — a pure gate, not a step; nothing besides the
-     * fan-out+gate pair itself is appended to the pipeline's node sequence)
-     * up front, mirroring how `.step()` requires `advance` in its own
-     * options rather than as a separate chained call.
-     */
-    fanOutStep<S extends AnyTypedStep, K extends LastSignalKeys<TSteps>>(step: S, config: FanOutStepConfig<TInput, TSteps, TFanOuts, S, K>): PipelineStepBuilder<TInput, TSteps, [...TFanOuts, S]>;
-    build(): PipelineDefinitionSpec;
-}
-/**
- * Entry-point builder returned by `pipeline()`. Only exposes `.step()` —
- * call that to receive a `PipelineStepBuilder`, which chains further
- * `.step()`/`.fanOutStep()` calls or finalizes with `.build()`.
- */
-export declare class PipelineBuilder<TInput extends ZodType> {
-    private readonly inputSchema;
-    private readonly meta;
-    private readonly nodes;
-    private readonly pipelineInputBindings;
-    private readonly pipelineStepInputBindings;
-    constructor(meta: PipelineMeta<TInput>);
-    step<S extends AnyTypedStep>(step: S, options: StepOptions<TInput, [], [], S>): PipelineStepBuilder<TInput, [S]>;
-}
-export { literal } from "./builder-helpers";
-export declare function pipeline<TInput extends ZodType = z.ZodUnknown>(meta: PipelineMeta<TInput>): PipelineBuilder<TInput>;

package/dist/definitions/pipelines/fan-out-builder.d.ts

@@ -1,66 +0,0 @@
-import type { ZodType } from "zod";
-import { type AdvanceAllCtx, type AdvanceAllResult, type AdvanceEachCtx, type AdvanceEachResult } from "../advancement-policies/cohort-fluent-rules";
-import { type AnyTypedStep, type FanOutInputCtx, type IsAny, type LastSignalKeys, type PipelineMeta, type RequiredInputKeys } from "./builder-helpers";
-import type { AnyBinding, PipelineNodeConfig } from "./define-pipeline";
-import { PipelineStepBuilder } from "./builder";
-/**
- * `.fanOutStep()` (issue #167) split out of `builder.ts` (which would
- * otherwise exceed this repo's `max-lines` limit) — genuinely mutually
- * referential with `PipelineStepBuilder` (`beginFanOut` both is called from
- * `PipelineStepBuilder.fanOutStep()` and returns a new one), so the import
- * cycle is structural, not accidental.
- */
-export type FanOutInputMapping<S extends AnyTypedStep> = Partial<Record<string, AnyBinding>> & (IsAny<S["__inputType"]> extends true ? unknown : S["__inputType"] extends object ? {
-    [K in RequiredInputKeys<S["__inputType"]>]: AnyBinding;
-} : unknown);
-/**
- * `.fanOutStep(step, config)`'s sole config argument — `step` itself is a
- * separate positional argument (mirroring `.step(step, options)`), not a
- * field on this object. `K` is inferred from the literal value of
- * `config.over` in the same pass TypeScript type-checks `config.input`,
- * the same mechanism `builder.ts`'s `StepOptions` already relies on for
- * `.step()` — see that type's doc comment for why overloads are avoided
- * here too.
- */
-export type FanOutStepConfig<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>, TFanOuts extends ReadonlyArray<AnyTypedStep>, S extends AnyTypedStep, K extends LastSignalKeys<TSteps> = LastSignalKeys<TSteps>> = {
-    /**
-     * The signal to resolve each branch from — constrained to the most
-     * recent ordinary step's declared signal keys (`TSteps`'s last element).
-     * Note this is the last *step*, not necessarily the fan-out's immediate
-     * graph predecessor: chaining a second `.fanOutStep()` right after
-     * `.advanceAll()` (with no intervening `.step()`) still only offers this
-     * same step's signals, since a `cohortGate` node produces no signals of
-     * its own to resolve from.
-     *
-     * A number-typed signal resolves a fixed branch count with no `item` on
-     * the input ctx (count-only mode); an array-typed signal resolves branch
-     * count from the array's length and adds a typed `item` to the input
-     * ctx for each branch.
-     */
-    over: K;
-    input?: (ctx: FanOutInputCtx<TInput, TSteps, TFanOuts, K>) => FanOutInputMapping<S>;
-    /**
-     * Every branch's own continue/block decision (even the default "always
-     * continue" must be declared explicitly) — evaluated once per branch
-     * against that branch's own signals.
-     */
-    advance: (ctx: AdvanceEachCtx<S["__signalKeys"], S["__signalTypeMap"]>) => AdvanceEachResult;
-    /**
-     * The whole-cohort decision, evaluated once the fan-out's branches have
-     * settled — a pure gate, not a step: nothing besides the fan-out+gate
-     * pair itself is appended to the pipeline's node sequence.
-     */
-    advanceAll: (ctx: AdvanceAllCtx) => AdvanceAllResult;
-    timeout?: number | null;
-};
-/**
- * Builds and pushes the `fanOut`+`cohortGate` node pair, resolves both the
- * per-branch (`advance`) and whole-cohort (`advanceAll`) policies from
- * `config`, and returns straight into a `PipelineStepBuilder` — mirroring
- * how `pushStep` in `builder.ts` resolves a step's `advance` policy inline
- * rather than through a chained `.advance()` call on an intermediate
- * builder. Called from `PipelineStepBuilder.fanOutStep()` — factored out
- * here (rather than inlined there) purely to keep the node-construction
- * logic next to the types it feeds.
- */
-export declare function beginFanOut<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>, TFanOuts extends ReadonlyArray<AnyTypedStep>, S extends AnyTypedStep, K extends LastSignalKeys<TSteps> = LastSignalKeys<TSteps>>(inputSchema: TInput, meta: Omit<PipelineMeta<TInput>, "additionalPipelineInput" | "additionalStepInput">, nodes: PipelineNodeConfig[], pipelineInputBindings: Record<string, AnyBinding>, pipelineStepInputBindings: Record<string, AnyBinding>, step: S, config: FanOutStepConfig<TInput, TSteps, TFanOuts, S, K>): PipelineStepBuilder<TInput, TSteps, [...TFanOuts, S]>;

package/dist/definitions/pipelines/input-accessor.d.ts

@@ -1,25 +0,0 @@
-import type { ZodType } from "zod";
-import type { PipelineInputBinding } from "./define-pipeline";
-type DeepAccessor<T> = T extends ReadonlyArray<infer U> ? {
-    readonly [index: number]: InputAccessor<U>;
-} : T extends object ? {
-    readonly [K in keyof T]: InputAccessor<T[K]>;
-} : object;
-/**
- * Type-level shape of the input accessor. Claims to be a `PipelineInputBinding`
- * so it slots into binding positions for type-checking; the actual binding
- * object is produced at builder time via `materializeAccessor`.
- */
-export type InputAccessor<T> = PipelineInputBinding & DeepAccessor<T>;
-/**
- * Creates a recursive proxy bound to the pipeline's input schema. Each property
- * access returns a new accessor whose `materializeAccessor()` yields a
- * `PipelineInputBinding` with the accumulated dot-path.
- *
- * The schema argument is used only for type inference — no runtime validation
- * is performed against it.
- */
-export declare function createInputAccessor<T extends ZodType>(_schema: T): InputAccessor<T["_output"]>;
-export declare function isInputAccessor(value: unknown): value is InputAccessor<unknown>;
-export declare function materializeAccessor(accessor: InputAccessor<unknown>): PipelineInputBinding;
-export {};