@boboddy/sdk 0.1.13-alpha → 0.1.15-alpha

package/dist/definitions/pipelines/define-pipeline.d.ts

@@ -1,13 +1,17 @@
-import type { ZodType } from "zod";
-import type { DotPaths, StepDefinitionSpec, TypedStepDefinitionSpec } from "../steps/define-step";
+import { type ZodType } from "zod";
+import type { StepDefinitionSpec, TypedStepDefinitionSpec } from "../steps/define-step";
 import { type AdvancementPolicy, type SerializedAdvancementPolicy, type SerializedComputedSignalDefinition } from "../advancement-policies/define-advancement-policy";
 export type { AdvancementPolicy, PipelineStepComputedSignalType, } from "../advancement-policies/define-advancement-policy";
 export { Computed, Rule, } from "../advancement-policies/define-advancement-policy";
-type AnyTypedStep = TypedStepDefinitionSpec<any, any, any>;
+type AnyTypedStep = TypedStepDefinitionSpec<any, any, any, any>;
 export type PipelineInputBinding = {
     source: "pipeline_input";
     path: string;
 };
+export type WorkItemBinding = {
+    source: "work_item";
+    field: "title" | "description";
+};
 export type StepSignalBinding = {
     source: "step_signal";
     step: AnyTypedStep;
@@ -17,23 +21,7 @@ export type StepOutputBinding = {
     source: "step_output";
     step: AnyTypedStep;
 };
-export type AnyBinding = PipelineInputBinding | StepSignalBinding | StepOutputBinding;
-/**
- * Binds a step input field to a field of the pipeline's top-level input.
- * The `path` is validated against the pipeline input schema at compile time.
- */
-export declare function fromPipelineInput<T extends ZodType>(_schema: T, path: DotPaths<T["_output"]>): PipelineInputBinding;
-/**
- * Binds a step input field to a named signal from a prior step.
- * `signalKey` is validated against the prior step's declared signal keys.
- */
-export declare function fromSignal<TStep extends AnyTypedStep>(step: TStep, signalKey: TStep["__signalKeys"]): StepSignalBinding;
-/**
- * Binds a step input field to the entire agent output of a prior step.
- * Use this when your consumer handles the full output object directly.
- * For a stable contract, prefer fromSignal() instead.
- */
-export declare function stepOutput(step: AnyTypedStep): StepOutputBinding;
+export type AnyBinding = PipelineInputBinding | WorkItemBinding | StepSignalBinding | StepOutputBinding;
 export type PipelineStepConfig<TStep extends AnyTypedStep = AnyTypedStep> = {
     step: TStep;
     /** Maps each step input field to an input source. Extra keys are ignored at runtime. */
@@ -54,6 +42,9 @@ export type PipelineStepConfig<TStep extends AnyTypedStep = AnyTypedStep> = {
 type SerializedBinding = {
     source: "pipeline_input";
     path: string;
+} | {
+    source: "work_item";
+    field: "title" | "description";
 } | {
     source: "step_signal";
     stepKey: string;
@@ -68,6 +59,7 @@ export type PipelineDefinitionSpec = {
     description: string | null;
     version: number;
     status: "draft" | "active" | "archived";
+    inputSchemaJson?: Record<string, unknown> | null;
     steps: Array<{
         stepKey: string;
         stepName: string;
@@ -78,44 +70,16 @@ export type PipelineDefinitionSpec = {
         advancementPolicyDefinition: SerializedAdvancementPolicy;
         computedSignalDefinitions: SerializedComputedSignalDefinition[];
     }>;
-    /** Step specs referenced by this pipeline. Populated by definePipeline so the push command can auto-push steps that aren't explicitly exported. */
+    /** Step specs referenced by this pipeline. Used by the push command to auto-push steps that aren't explicitly exported. */
     _stepDefinitions?: StepDefinitionSpec[];
 };
-/**
- * Untyped input shape used for documentation and as the internal implementation
- * target. Call sites use the generic overload below which provides per-step
- * signal key validation.
- */
 export type DefinePipelineInput = {
     key: string;
     name: string;
     description?: string | null;
     version?: number;
     status?: "draft" | "active";
-    steps: Array<PipelineStepConfig>;
+    input?: ZodType | null;
+    steps: ReadonlyArray<PipelineStepConfig>;
 };
-/**
- * Defines a pipeline from an ordered list of step configs.
- *
- * Each step's `advancement` policy is typed against that step's declared signal
- * keys — passing an unknown signal key to `Rule.signal()` / `Rule.when()` is a
- * compile-time error. Inline `Computed.X(...)` tokens can also be used in the
- * signal position; they're walked out of the rules tree at serialization time
- * and emitted as the step's `computedSignalDefinitions`.
- *
- * TypeScript achieves per-element signal key checking by constraining `TSteps`
- * to a tuple of step instances (`AnyTypedStep[]`), not step configs. Each element
- * of `steps` is then typed as `PipelineStepConfig<TSteps[K]>`, giving TypeScript
- * a direct inference site: `step: TSteps[K]` matches the concrete step instance,
- * which carries the signal key union via `__signalKeys`.
- */
-export declare function definePipeline<const TSteps extends ReadonlyArray<AnyTypedStep>>(config: {
-    key: string;
-    name: string;
-    description?: string | null;
-    version?: number;
-    status?: "draft" | "active";
-    steps: {
-        [K in keyof TSteps]: PipelineStepConfig<TSteps[K]>;
-    };
-}): PipelineDefinitionSpec;
+export declare function buildPipelineSpec(config: DefinePipelineInput): PipelineDefinitionSpec;

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

@@ -1,2 +1,4 @@
 export * from "./define-pipeline";
+export * from "./builder";
+export * from "./input-accessor";
 export * from "./pipeline-definitions-client";