@boboddy/sdk 0.4.2 → 0.4.3

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

@@ -2,6 +2,7 @@ import { z, type ZodType } from "zod";
 import { type AdditionalStepInputBinding, type TypedStepDefinitionSpec } from "../steps/define-step";
 import { type AnyBinding, type FanOutItemBinding, type LiteralBinding, type SignalsListBinding, type StepOutputBinding, type StepSignalBinding, type WorkItemBinding } from "./define-pipeline";
 import { type InputAccessor } from "./input-accessor";
+import { type WorkItemTopLevelField } from "./work-item-fields";
 export type AnyTypedStep = TypedStepDefinitionSpec<any, any, any, any>;
 type ElementOf<T extends ReadonlyArray<unknown>> = T extends ReadonlyArray<infer U> ? U : never;
 export type LastStep<T extends ReadonlyArray<AnyTypedStep>> = T extends readonly [...AnyTypedStep[], infer L] ? L extends AnyTypedStep ? L : never : never;
@@ -30,10 +31,31 @@ export type FanOutInputCtx<TInput extends ZodType, TSteps extends ReadonlyArray<
     item: FanOutItemBinding & FanOutItemType<TSteps, K>;
 });
 export type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Work-item accessor for `additionalPipelineInput.bindings(({ workItem }) => ...)`:
+ * a top-level property (`workItem.title`, `workItem.platform`,
+ * `workItem.url`, ...) for every member of `WORK_ITEM_TOP_LEVEL_FIELDS`, plus
+ * `workItem.field(name)` for the platform-specific `fields` bag.
+ *
+ * Mirrors the default-pipeline-assignment DSL's `WorkItemAssignmentAccessor`
+ * (`define-default-pipeline-assignment.ts`) in which properties it exposes —
+ * both are generated off the same `WORK_ITEM_TOP_LEVEL_FIELDS` list — but
+ * returns a plain `WorkItemBinding` per property rather than a
+ * comparator-bound `AssignmentFieldRef`: a regular pipeline input binding
+ * has no conditions to compare against, it's just "read this work-item
+ * property into this input field."
+ *
+ * `field`'s optional `TName` type parameter accepts a literal union of known
+ * field names (e.g. the `WorkItemFieldName` type `boboddy pipelines pull`
+ * generates into `work-item-fields.ts`) for compile-time validation and
+ * autocomplete on the field name, exactly like the assignment DSL's
+ * `workItem.field<TName>(...)`. Defaults to permissive `string`, so
+ * `workItem.field(name)` with no type argument keeps working as before.
+ */
 export type WorkItemAccessor = {
-    readonly title: WorkItemBinding;
-    readonly description: WorkItemBinding;
-    readonly field: (fieldName: string) => WorkItemBinding;
+    readonly [K in WorkItemTopLevelField]: WorkItemBinding;
+} & {
+    field<TName extends string = string>(fieldName: TName): WorkItemBinding;
 };
 export type PinnedWorkItemComment = {
     createdAt: string;
@@ -91,7 +113,14 @@ export type PipelineMeta<TInput extends ZodType = z.ZodUnknown> = {
     additionalStepInput?: {
         schema: ZodType;
         bindings: (ctx: {
-            workItemField: (fieldName: string) => WorkItemBinding;
+            /**
+             * References a platform-specific field (Jira custom field, GitHub
+             * label, etc.) in the work item's `fields` bag. `TName` optionally
+             * accepts a literal union of known field names (e.g. the generated
+             * `WorkItemFieldName`) for compile-time validation and autocomplete,
+             * exactly like `WorkItemAccessor.field` above.
+             */
+            workItemField: <TName extends string = string>(fieldName: TName) => WorkItemBinding;
             literal: (value: unknown) => LiteralBinding;
         }) => Partial<Record<string, AdditionalStepInputBinding>>;
     };

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

@@ -1,4 +1,5 @@
 import type { PipelineDefinitionSpec } from "./define-pipeline";
+import { type WorkItemTopLevelField, type WorkItemTopLevelFieldTypeMap } from "./work-item-fields";
 /**
  * The reserved filename for the default pipeline assignment file.
  * This file is NOT treated as a pipeline definition by the push scanner.
@@ -47,31 +48,80 @@ export interface AssignmentGroup {
     readonly _condition: AssignmentCondition;
 }
 type AssignmentNestable = AssignmentLeaf | AssignmentGroup;
-/** Comparator-bound reference to a work-item field or context fact. */
-export interface AssignmentFieldRef {
-    eq(value: unknown): AssignmentLeaf;
-    ne(value: unknown): AssignmentLeaf;
+/**
+ * `.gt`/`.gte`/`.lt`/`.lte` are only ever meaningful for numeric fields.
+ * Intersected onto `AssignmentFieldRef<T>` only when `T` is (or includes)
+ * `number`, so e.g. `workItem.title.gt(...)` doesn't even type-check, let
+ * alone appear in autocomplete.
+ */
+type NumericComparators = {
     gt(value: number): AssignmentLeaf;
     gte(value: number): AssignmentLeaf;
     lt(value: number): AssignmentLeaf;
     lte(value: number): AssignmentLeaf;
-    in(values: ReadonlyArray<unknown>): AssignmentLeaf;
-    notIn(values: ReadonlyArray<unknown>): AssignmentLeaf;
-    contains(value: unknown): AssignmentLeaf;
-    doesNotContain(value: unknown): AssignmentLeaf;
-}
+};
+/**
+ * Comparator-bound reference to a work-item field or context fact.
+ *
+ * `T` is the field's value type (defaulting to `unknown`, which preserves
+ * the pre-generic behavior for any caller that doesn't otherwise constrain
+ * it). `.contains`/`.doesNotContain` narrow to the array element type when
+ * `T` is an array — json-rules-engine's `contains`/`doesNotContain`
+ * operators check array-membership (or substring-membership for strings)
+ * against the fact's actual runtime shape, so an array-typed field's
+ * `.contains(...)` should accept one element, not the whole array.
+ */
+export type AssignmentFieldRef<T = unknown> = {
+    eq(value: T): AssignmentLeaf;
+    ne(value: T): AssignmentLeaf;
+    in(values: ReadonlyArray<T>): AssignmentLeaf;
+    notIn(values: ReadonlyArray<T>): AssignmentLeaf;
+    contains(value: T extends ReadonlyArray<infer U> ? U : T): AssignmentLeaf;
+    doesNotContain(value: T extends ReadonlyArray<infer U> ? U : T): AssignmentLeaf;
+} & (T extends number ? NumericComparators : Record<string, never>);
+/** Comparator-bound accessor for the work item passed to `defaultPipelineAssignment`. */
+export type WorkItemAssignmentAccessor = {
+    [K in WorkItemTopLevelField]: AssignmentFieldRef<WorkItemTopLevelFieldTypeMap[K]>;
+} & {
+    /**
+     * Accessor for a platform-specific field (Jira custom field, GitHub label,
+     * etc.) stored in the work item's `fields` bag. Since `fields` keys and
+     * value shapes are platform- and project-dependent, there is no static
+     * schema to check either against by default.
+     *
+     * Two independent, optional type parameters:
+     *  - `TName` constrains the `name` argument itself — pass a literal union
+     *    of known field names (e.g. the `WorkItemFieldName` type
+     *    `boboddy pipelines pull` generates into `work-item-fields.ts`) to get
+     *    compile-time validation and autocomplete on the field name.
+     *  - `TValue` types the comparator (`.eq`/`.gte`/etc.) argument, exactly
+     *    like the top-level accessors above — pass it for a known-shaped
+     *    custom field (e.g. a numeric one).
+     * Both default to permissive types, so `workItem.field(name)` with no
+     * type arguments keeps working exactly as before.
+     *
+     * @example
+     * workItem.field("issueType").eq("bug")
+     * workItem.field("labels").contains("regression")
+     * workItem.field<WorkItemFieldName>("issueType").eq("bug")
+     * workItem.field<WorkItemFieldName, number>("storyPoints").gte(3)
+     */
+    field<TName extends string = string, TValue = unknown>(name: TName): AssignmentFieldRef<TValue>;
+};
 export type DefaultPipelineAssignmentCtx = {
     /**
-     * Work-item field accessor.
+     * Work-item accessor: top-level properties (`workItem.title`,
+     * `workItem.platform`, `workItem.url`, ...) plus `workItem.field(name)`
+     * for the platform-specific `fields` bag.
      *
      * @example
      * workItem.field("issueType").eq("bug").then(assign(bugTriage))
      * workItem.field("labels").contains("regression").then(assign(regressionReview))
      * workItem.field("status").eq("resolved").then(skip())
+     * workItem.platform.eq("github").then(assign(githubTriage))
+     * workItem.title.contains("[urgent]").then(assign(urgentTriage))
      */
-    workItem: {
-        field(name: string): AssignmentFieldRef;
-    };
+    workItem: WorkItemAssignmentAccessor;
     /**
      * Context facts for the current ingestion event.
      * `context.isNew` is `true` when the work item is being created for the first time.
@@ -80,7 +130,7 @@ export type DefaultPipelineAssignmentCtx = {
      * context.isNew.eq(true).then(assign(onboarding))
      */
     context: {
-        isNew: AssignmentFieldRef;
+        isNew: AssignmentFieldRef<boolean>;
     };
     /**
      * Outcome: assign the work item to the given pipeline.

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

@@ -3,3 +3,4 @@ export * from "./builder";
 export * from "./input-accessor";
 export * from "./pipeline-definitions-client";
 export * from "./define-default-pipeline-assignment";
+export * from "./work-item-fields";

package/dist/definitions/pipelines/index.js

@@ -14821,14 +14821,48 @@ function materializeAccessor(accessor) {
   };
 }
 
+// src/definitions/pipelines/work-item-fields.ts
+var WORK_ITEM_TOP_LEVEL_FIELDS = [
+  "id",
+  "projectId",
+  "platform",
+  "platformId",
+  "platformKey",
+  "url",
+  "title",
+  "description",
+  "sourceCreatedAt",
+  "sourceUpdatedAt",
+  "createdByUserId",
+  "parentWorkItemId",
+  "createdAt",
+  "updatedAt"
+];
+var WORK_ITEM_FIELDS_PATH_PREFIX = "fields.";
+function resolveWorkItemFieldPath(record2, path) {
+  if (typeof record2 !== "object" || record2 === null)
+    return;
+  const asRecord = record2;
+  if (path.startsWith(WORK_ITEM_FIELDS_PATH_PREFIX)) {
+    const fieldName = path.slice(WORK_ITEM_FIELDS_PATH_PREFIX.length);
+    const fields = asRecord["fields"];
+    if (typeof fields !== "object" || fields === null)
+      return;
+    return fields[fieldName];
+  }
+  return asRecord[path];
+}
+
 // src/definitions/pipelines/builder-helpers.ts
 var WORK_ITEM_ACCESSOR = Object.freeze({
-  title: Object.freeze({ source: "work_item", field: "title" }),
-  description: Object.freeze({
+  ...Object.fromEntries(WORK_ITEM_TOP_LEVEL_FIELDS.map((field) => [
+    field,
+    Object.freeze({ source: "work_item", field })
+  ])),
+  field: (fieldName) => Object.freeze({
     source: "work_item",
-    field: "description"
-  }),
-  field: (fieldName) => Object.freeze({ source: "work_item", field: `fields.${fieldName}` })
+    field: `${WORK_ITEM_FIELDS_PATH_PREFIX}${fieldName}`
+  })
 });
 var WORK_ITEM_FIELD_BINDINGS = {
   workItemTitle: { source: "work_item", field: "title" },
@@ -14879,7 +14913,7 @@ function resolveAdditionalStepInputBindings(label, definition) {
   const raw = definition.bindings({
     workItemField: (fieldName) => ({
       source: "work_item",
-      field: `fields.${fieldName}`
+      field: `${WORK_ITEM_FIELDS_PATH_PREFIX}${fieldName}`
     }),
     literal: literal2
   });
@@ -16892,7 +16926,7 @@ function makeLeaf(fact, path, operator, value) {
   };
 }
 function makeFieldRef(fact, path) {
-  return {
+  const untyped = {
     eq: (v) => makeLeaf(fact, path, "equal", v),
     ne: (v) => makeLeaf(fact, path, "notEqual", v),
     gt: (v) => makeLeaf(fact, path, "greaterThan", v),
@@ -16904,6 +16938,16 @@ function makeFieldRef(fact, path) {
     contains: (v) => makeLeaf(fact, path, "contains", v),
     doesNotContain: (v) => makeLeaf(fact, path, "doesNotContain", v)
   };
+  return untyped;
+}
+function buildWorkItemAccessor() {
+  const accessor = {
+    field: (name) => makeFieldRef("workItem", `$.${WORK_ITEM_FIELDS_PATH_PREFIX}${name}`)
+  };
+  for (const key of WORK_ITEM_TOP_LEVEL_FIELDS) {
+    accessor[key] = makeFieldRef("workItem", `$.${key}`);
+  }
+  return accessor;
 }
 function makeAssign(pipeline2) {
   if (typeof pipeline2 !== "object" || typeof pipeline2["key"] !== "string" || !Array.isArray(pipeline2["nodeDefinitions"])) {
@@ -16926,9 +16970,7 @@ function makeGroup(mode, refs) {
 }
 function buildCtx() {
   return {
-    workItem: {
-      field: (name) => makeFieldRef("workItem", `$.fields.${name}`)
-    },
+    workItem: buildWorkItemAccessor(),
     context: {
       isNew: makeFieldRef("context", "$.isNew")
     },
@@ -17008,6 +17050,7 @@ function isDefaultPipelineAssignmentSpec(value) {
 }
 export {
   serializeDefaultPipelineAssignment,
+  resolveWorkItemFieldPath,
   pipeline,
   materializeAccessor,
   literal2 as literal,
@@ -17017,6 +17060,8 @@ export {
   createPipelineDefinitionsClient,
   createInputAccessor,
   buildPipelineSpec,
+  WORK_ITEM_TOP_LEVEL_FIELDS,
+  WORK_ITEM_FIELDS_PATH_PREFIX,
   Rule,
   PipelineStepBuilder,
   PipelineBuilder,

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

@@ -20,7 +20,9 @@ declare const buildPipelineDefinitionsClient: (pipelineDefinitions: PipelineDefi
         description: string | unknown;
         status: "draft" | "active" | "archived";
         archivedAt: string | unknown;
-        inputSchemaJson: unknown;
+        inputSchemaJson: {
+            [key: string]: unknown;
+        } | unknown;
         stepDefinitions: Array<{
             id: string;
             pipelineDefinitionId: string;
@@ -51,7 +53,9 @@ declare const buildPipelineDefinitionsClient: (pipelineDefinitions: PipelineDefi
                 };
             } | unknown;
             timeoutSeconds: number | unknown;
-            retryPolicyJson: unknown;
+            retryPolicyJson: {
+                [key: string]: unknown;
+            } | unknown;
             advancementPolicyDefinition: {
                 id: string;
                 pipelineStepDefinitionId: string;
@@ -100,7 +104,9 @@ declare const buildPipelineDefinitionsClient: (pipelineDefinitions: PipelineDefi
                     }>;
                 };
                 defaultEventType: "continue" | "block" | "complete" | "route";
-                defaultEventParamsJson: unknown;
+                defaultEventParamsJson: {
+                    [key: string]: unknown;
+                } | unknown;
                 allowedEventTypes: Array<"continue" | "block" | "complete" | "route">;
                 createdAt: string;
                 updatedAt: string;
@@ -110,7 +116,9 @@ declare const buildPipelineDefinitionsClient: (pipelineDefinitions: PipelineDefi
                 key: string;
                 type: "average" | "weighted_average" | "sum" | "min" | "max" | "count" | "boolean_any" | "boolean_all";
                 inputSignalKeys: Array<string>;
-                configJson: unknown;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
                 availableWhenResultStatusIn: Array<string> | unknown;
                 createdAt: string;
                 updatedAt: string;
@@ -138,7 +146,9 @@ declare const buildPipelineDefinitionsClient: (pipelineDefinitions: PipelineDefi
         description: string | unknown;
         status: "draft" | "active" | "archived";
         archivedAt: string | unknown;
-        inputSchemaJson: unknown;
+        inputSchemaJson: {
+            [key: string]: unknown;
+        } | unknown;
         stepDefinitions: Array<{
             id: string;
             pipelineDefinitionId: string;
@@ -169,7 +179,9 @@ declare const buildPipelineDefinitionsClient: (pipelineDefinitions: PipelineDefi
                 };
             } | unknown;
             timeoutSeconds: number | unknown;
-            retryPolicyJson: unknown;
+            retryPolicyJson: {
+                [key: string]: unknown;
+            } | unknown;
             advancementPolicyDefinition: {
                 id: string;
                 pipelineStepDefinitionId: string;
@@ -218,7 +230,9 @@ declare const buildPipelineDefinitionsClient: (pipelineDefinitions: PipelineDefi
                     }>;
                 };
                 defaultEventType: "continue" | "block" | "complete" | "route";
-                defaultEventParamsJson: unknown;
+                defaultEventParamsJson: {
+                    [key: string]: unknown;
+                } | unknown;
                 allowedEventTypes: Array<"continue" | "block" | "complete" | "route">;
                 createdAt: string;
                 updatedAt: string;
@@ -228,7 +242,9 @@ declare const buildPipelineDefinitionsClient: (pipelineDefinitions: PipelineDefi
                 key: string;
                 type: "average" | "weighted_average" | "sum" | "min" | "max" | "count" | "boolean_any" | "boolean_all";
                 inputSignalKeys: Array<string>;
-                configJson: unknown;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
                 availableWhenResultStatusIn: Array<string> | unknown;
                 createdAt: string;
                 updatedAt: string;

package/dist/definitions/pipelines/work-item-fields.d.ts

@@ -0,0 +1,98 @@
+import type { GetApiWorkItemsByWorkItemIdResponses } from "../../generated/types.gen";
+/**
+ * Top-level work-item properties addressable by every work-item binding
+ * mechanism in the SDK: the default-pipeline-assignment DSL's
+ * `workItem.<field>` accessor (`define-default-pipeline-assignment.ts`) and
+ * the regular pipeline/step `workItem.<field>` accessor
+ * (`builder-helpers.ts`'s `WorkItemAccessor`) — and, reversed, both
+ * `boboddy pipelines pull` file generators
+ * (`default-pipeline-assignment-file-generator.ts`,
+ * `pipeline-file-generator.ts`). `fields` is deliberately excluded from this
+ * list: it's reached via `.field(name)` on every one of those accessors, not
+ * as a top-level property.
+ *
+ * This is the single source of truth for the list — it must stay in sync
+ * with the `workItem` fact/context shape every corresponding server-side
+ * resolver publishes (`buildFacts` in
+ * `evaluate-default-pipeline-assignment.ts`; `buildResolvedWorkItemContext`
+ * in `resolve-node-input.ts`).
+ */
+export declare const WORK_ITEM_TOP_LEVEL_FIELDS: readonly ["id", "projectId", "platform", "platformId", "platformKey", "url", "title", "description", "sourceCreatedAt", "sourceUpdatedAt", "createdByUserId", "parentWorkItemId", "createdAt", "updatedAt"];
+export type WorkItemTopLevelField = (typeof WORK_ITEM_TOP_LEVEL_FIELDS)[number];
+/**
+ * The literal union of valid work-item platforms, sourced from the generated
+ * OpenAPI response type (`GetApiWorkItemsByWorkItemIdResponses[200]["platform"]`)
+ * rather than hand-duplicated, so it cannot drift from the API contract. It
+ * must mirror `WorkItemPlatform` in
+ * `packages/core/src/work-items/work-item/domain/work-item-platform.ts`.
+ */
+type WorkItemPlatformLiteral = GetApiWorkItemsByWorkItemIdResponses[200]["platform"];
+/**
+ * Per-field value types for every member of `WORK_ITEM_TOP_LEVEL_FIELDS`,
+ * mirroring exactly what the server-side resolvers publish at evaluation/
+ * resolution time (`buildFacts` for default-pipeline-assignment;
+ * `buildResolvedWorkItemContext` for regular pipeline/step input bindings).
+ * Notably, `sourceCreatedAt`/`sourceUpdatedAt`/`createdAt`/`updatedAt` are
+ * serialized as ISO date strings (or `null`), never `Date` objects.
+ */
+export type WorkItemTopLevelFieldTypeMap = {
+    id: string;
+    projectId: string;
+    platform: WorkItemPlatformLiteral;
+    platformId: string | null;
+    platformKey: string;
+    url: string | null;
+    title: string;
+    description: string | null;
+    sourceCreatedAt: string | null;
+    sourceUpdatedAt: string | null;
+    createdByUserId: string | null;
+    parentWorkItemId: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+/**
+ * The path prefix marking a reference into a work item's platform-specific
+ * `fields` bag (a Jira custom field, a GitHub label, etc.), as opposed to a
+ * `WorkItemTopLevelField`. Shared by every accessor that authors these paths
+ * (`workItem.field(name)` in both the default-pipeline-assignment DSL and
+ * the regular pipeline/step `WorkItemAccessor`) and every resolver that
+ * reads them back (`resolveWorkItemFieldPath` below; the JSONPath-rooted
+ * variant in `evaluate-default-pipeline-assignment.ts`, which layers a `$.`
+ * prefix on top of this same convention).
+ */
+export declare const WORK_ITEM_FIELDS_PATH_PREFIX = "fields.";
+/**
+ * Resolves a work-item path — either a `WorkItemTopLevelField` name (a
+ * single, code-controlled segment) or a `fields.<name>` reference into the
+ * platform-specific `fields` bag — against a plain object shaped like
+ * `WorkItemTopLevelFieldTypeMap & { fields: ... }`.
+ *
+ * `<name>` in `fields.<name>` is an arbitrary, unescaped, platform-supplied
+ * field name (a Jira custom field label, a GitHub key, etc.) that may
+ * contain any character, including `.`, `[`, `]`, `~`, `^`, `;`, or even be
+ * the empty string. A naive dot-splitting path walker would silently
+ * misresolve a field literally named `"a.b"` as nested property access
+ * (`fields.a.b`) instead of the flat key `fields["a.b"]` — a silent-wrong-
+ * match hazard, not a visible error, since the walker degrades to "no
+ * match"/"wrong match" rather than throwing.
+ *
+ * This resolver sidesteps that hazard entirely: everything after `fields.`
+ * is treated as one atomic, unsplit key. Every work-item path resolver in
+ * the codebase must use this same convention for a field name to round-trip
+ * correctly — see `evaluate-default-pipeline-assignment.ts`'s
+ * `resolveWorkItemAssignmentPath` (which layers `$.` path-rooting on top of
+ * this function) and `resolve-node-input.ts`'s `work_item` binding
+ * resolution (which calls this function directly, replacing what used to be
+ * a dot-splitting walker shared with unrelated binding sources and
+ * susceptible to the exact hazard described above).
+ *
+ * `path` is untyped (`string`, not `WorkItemTopLevelField | \`fields.${string}\``)
+ * because callers validate membership separately
+ * (`WORK_ITEM_TOP_LEVEL_FIELDS`/`isSupportedWorkItemField`) before ever
+ * reaching a resolver — this function's contract is purely "resolve
+ * whatever path string you hand it, treating `fields.` as atomic," not
+ * "validate the path."
+ */
+export declare function resolveWorkItemFieldPath(record: unknown, path: string): unknown;
+export {};

package/dist/definitions/steps/define-step.d.ts

@@ -1,6 +1,7 @@
 import type { ZodType } from "zod";
 import type { AnyStepFeature, FeatureResultExtensions, FeatureSignalKeys } from "./step-features";
 import { type PromptTemplateContext } from "./prompt-template";
+import type { LiteralBinding, WorkItemBinding } from "../pipelines/define-pipeline";
 type OpenCodeMcpServers = Record<string, {
     type: "local";
     command: string[];
@@ -89,14 +90,24 @@ export type DefineStepInput<TInput extends ZodType = ZodType, TResult extends Zo
     status?: "draft" | "active";
     executionMode?: "workspace" | "no_workspace";
 };
-export type AdditionalStepInputLiteralBinding = {
-    source: "literal";
-    value: unknown;
-};
-export type AdditionalStepInputBinding = {
-    source: "work_item";
-    field: string;
-} | AdditionalStepInputLiteralBinding;
+/**
+ * @deprecated Alias for `LiteralBinding` (`define-pipeline.ts`) — the two
+ * used to be independently declared, structurally-identical types. Kept
+ * only so existing imports of this name keep working.
+ */
+export type AdditionalStepInputLiteralBinding = LiteralBinding;
+/**
+ * The binding sources available to `PipelineMeta.additionalStepInput`'s
+ * `bindings` callback (`workItemField(...)`/`literal(...)` in
+ * `builder-helpers.ts`'s `resolveAdditionalStepInputBindings`) — the same
+ * `WorkItemBinding`/`LiteralBinding` shapes `.step()`'s own `input` mapper
+ * uses (`define-pipeline.ts`'s `AnyBinding`), restricted to the subset
+ * `resolveAdditionalStepInputBindings` can actually produce. Previously an
+ * independently-declared `{ source: "work_item"; field: string }` union
+ * member that had drifted apart from `WorkItemBinding` in shape only by
+ * coincidence, not by design.
+ */
+export type AdditionalStepInputBinding = WorkItemBinding | LiteralBinding;
 export type StepDefinitionSpec = {
     key: string;
     name: string;

package/dist/definitions/steps/step-definitions-client.d.ts

@@ -18,8 +18,12 @@ declare const buildStepDefinitionsClient: (stepDefinitions: StepDefinitions) =>
         version: number;
         kind: "built_in" | "user_defined";
         executionMode: "workspace" | "no_workspace";
-        inputSchemaJson: unknown;
-        resultSchemaJson: unknown;
+        inputSchemaJson: {
+            [key: string]: unknown;
+        } | unknown;
+        resultSchemaJson: {
+            [key: string]: unknown;
+        } | unknown;
         opencodeMcpJson: {
             [key: string]: {
                 type: string;
@@ -82,8 +86,12 @@ declare const buildStepDefinitionsClient: (stepDefinitions: StepDefinitions) =>
         version: number;
         kind: "built_in" | "user_defined";
         executionMode: "workspace" | "no_workspace";
-        inputSchemaJson: unknown;
-        resultSchemaJson: unknown;
+        inputSchemaJson: {
+            [key: string]: unknown;
+        } | unknown;
+        resultSchemaJson: {
+            [key: string]: unknown;
+        } | unknown;
         opencodeMcpJson: {
             [key: string]: {
                 type: string;
@@ -151,8 +159,12 @@ declare const buildStepDefinitionsClient: (stepDefinitions: StepDefinitions) =>
         version: number;
         kind: "built_in" | "user_defined";
         executionMode: "workspace" | "no_workspace";
-        inputSchemaJson: unknown;
-        resultSchemaJson: unknown;
+        inputSchemaJson: {
+            [key: string]: unknown;
+        } | unknown;
+        resultSchemaJson: {
+            [key: string]: unknown;
+        } | unknown;
         opencodeMcpJson: {
             [key: string]: {
                 type: string;