@tagma/sdk 0.7.0 → 0.7.1

package/src/ports.ts

@@ -270,6 +270,7 @@ export type BindingInputResolution =
       readonly kind: 'blocked';
       readonly missingRequired: readonly string[];
       readonly ambiguous: readonly { input: string; producers: readonly string[] }[];
+      readonly typeErrors: readonly { input: string; reason: string }[];
       readonly reason: string;
     };
 
@@ -287,6 +288,7 @@ export function resolveTaskBindingInputs(
   const missingRequired: string[] = [];
   const missingOptional: string[] = [];
   const ambiguous: { input: string; producers: string[] }[] = [];
+  const typeErrors: { input: string; reason: string }[] = [];
 
   for (const [name, binding] of Object.entries(bindings)) {
     let value: unknown;
@@ -321,10 +323,16 @@ export function resolveTaskBindingInputs(
       continue;
     }
 
-    inputs[name] = value;
+    const coerced = coerceBindingValue(binding, value);
+    if (coerced.kind === 'error') {
+      typeErrors.push({ input: name, reason: coerced.reason });
+      continue;
+    }
+
+    inputs[name] = coerced.value;
   }
 
-  if (missingRequired.length > 0 || ambiguous.length > 0) {
+  if (missingRequired.length > 0 || ambiguous.length > 0 || typeErrors.length > 0) {
     const lines: string[] = [];
     if (missingRequired.length > 0) {
       lines.push(`missing required binding input(s): ${missingRequired.join(', ')}`);
@@ -335,7 +343,10 @@ export function resolveTaskBindingInputs(
           `(${amb.producers.join(', ')}) — use "taskId.outputs.${amb.input}"`,
       );
     }
-    return { kind: 'blocked', missingRequired, ambiguous, reason: lines.join('\n') };
+    for (const te of typeErrors) {
+      lines.push(`binding input "${te.input}": ${te.reason}`);
+    }
+    return { kind: 'blocked', missingRequired, ambiguous, typeErrors, reason: lines.join('\n') };
   }
 
   return { kind: 'ready', inputs, missingOptional };
@@ -494,6 +505,21 @@ function coerceValue(port: PortDef, raw: unknown): Coercion {
   }
 }
 
+function coerceBindingValue(
+  binding: { readonly type?: PortType; readonly enum?: readonly string[] },
+  raw: unknown,
+): Coercion {
+  if (!binding.type) return { kind: 'ok', value: raw };
+  return coerceValue(
+    {
+      name: 'binding',
+      type: binding.type,
+      ...(binding.enum ? { enum: binding.enum } : {}),
+    },
+    raw,
+  );
+}
+
 function describe(v: unknown): string {
   if (v === null) return 'null';
   if (Array.isArray(v)) return 'array';
@@ -630,7 +656,13 @@ export function extractTaskBindingOutputs(
       continue;
     }
 
-    outputs[name] = value;
+    const coerced = coerceBindingValue(binding, value);
+    if (coerced.kind === 'error') {
+      missing.push(`"${name}": ${coerced.reason}`);
+      continue;
+    }
+
+    outputs[name] = coerced.value;
   }
 
   return {

package/src/schema-ports.test.ts

@@ -1,19 +1,12 @@
 import { describe, expect, test } from 'bun:test';
 import yaml from 'js-yaml';
 import type { PipelineConfig, RawPipelineConfig } from './types';
-import {
-  deresolvePipeline,
-  parseYaml,
-  resolveConfig,
-  serializePipeline,
-} from './schema';
+import { deresolvePipeline, parseYaml, resolveConfig, serializePipeline } from './schema';
 
 const WORK_DIR = process.platform === 'win32' ? 'D:\\fake-work' : '/fake-work';
 
-// ─── resolveConfig preserves ports ───────────────────────────────────
-
-describe('resolveConfig — ports passthrough', () => {
-  test('raw lightweight bindings survive onto the resolved task', () => {
+describe('schema — unified bindings passthrough', () => {
+  test('typed inputs and outputs survive onto the resolved task', () => {
     const raw: RawPipelineConfig = {
       name: 'p',
       tracks: [
@@ -24,94 +17,19 @@ describe('resolveConfig — ports passthrough', () => {
             {
               id: 'a',
               command: 'echo "{{inputs.city}}"',
-              inputs: {
-                city: { from: 't.plan.outputs.city', required: true },
-              },
-              outputs: {
-                report: { from: 'json.reportPath' },
-              },
+              inputs: { city: { from: 't.plan.outputs.city', type: 'string', required: true } },
+              outputs: { report: { from: 'json.reportPath', type: 'string' } },
             },
           ],
         },
       ],
     };
-    const resolved = resolveConfig(raw, WORK_DIR);
-    const task = resolved.tracks[0]!.tasks[0]!;
+    const task = resolveConfig(raw, WORK_DIR).tracks[0]!.tasks[0]!;
     expect(task.inputs).toEqual(raw.tracks[0]!.tasks[0]!.inputs!);
     expect(task.outputs).toEqual(raw.tracks[0]!.tasks[0]!.outputs!);
   });
 
-  test('raw ports survive onto the resolved task', () => {
-    const raw: RawPipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          tasks: [
-            {
-              id: 'a',
-              prompt: 'do it',
-              ports: {
-                inputs: [{ name: 'city', type: 'string', required: true }],
-                outputs: [{ name: 'temp', type: 'number', description: 'Celsius' }],
-              },
-            },
-          ],
-        },
-      ],
-    };
-    const resolved = resolveConfig(raw, WORK_DIR);
-    const task = resolved.tracks[0]!.tasks[0]!;
-    expect(task.ports).toBeDefined();
-    expect(task.ports!.inputs).toEqual([
-      { name: 'city', type: 'string', required: true },
-    ]);
-    expect(task.ports!.outputs).toEqual([
-      { name: 'temp', type: 'number', description: 'Celsius' },
-    ]);
-  });
-
-  test('tasks without ports still resolve with ports === undefined', () => {
-    const raw: RawPipelineConfig = {
-      name: 'p',
-      tracks: [
-        { id: 't', name: 'T', tasks: [{ id: 'a', prompt: 'do it' }] },
-      ],
-    };
-    const resolved = resolveConfig(raw, WORK_DIR);
-    expect(resolved.tracks[0]!.tasks[0]!.ports).toBeUndefined();
-  });
-
-  test('ports is not inherited from track or pipeline', () => {
-    // Ports describe a per-task I/O contract. If we accidentally pulled
-    // them from track defaults, two tasks in the same track would share
-    // input ports and downstream data-flow would be ambiguous. Test that
-    // a track with an unrelated `middlewares` default doesn't spread
-    // anywhere unexpected — purely a regression guard for the no-inherit
-    // invariant.
-    const raw: RawPipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          middlewares: [{ type: 'static_context', file: './x' }],
-          tasks: [{ id: 'a', prompt: 'x' }, { id: 'b', prompt: 'y' }],
-        },
-      ],
-    };
-    const resolved = resolveConfig(raw, WORK_DIR);
-    for (const task of resolved.tracks[0]!.tasks) {
-      expect(task.ports).toBeUndefined();
-    }
-  });
-});
-
-// ─── deresolvePipeline preserves ports ───────────────────────────────
-
-describe('deresolvePipeline — ports round-trip', () => {
-  test('lightweight bindings round-trip', () => {
+  test('typed inputs and outputs round-trip through deresolve', () => {
     const raw: RawPipelineConfig = {
       name: 'p',
       tracks: [
@@ -123,103 +41,49 @@ describe('deresolvePipeline — ports round-trip', () => {
               id: 'a',
               command: 'echo "{{inputs.city}}"',
               inputs: {
-                city: { from: 't.plan.outputs.city', required: true },
-                mode: { default: 'quick' },
-              },
-              outputs: {
-                raw: { from: 'stdout' },
+                city: {
+                  from: 't.plan.outputs.city',
+                  type: 'enum',
+                  enum: ['Shanghai', 'Paris'],
+                  required: true,
+                },
               },
+              outputs: { raw: { from: 'stdout' } },
             },
           ],
         },
       ],
     };
-    const resolved = resolveConfig(raw, WORK_DIR);
-    const back = deresolvePipeline(resolved, WORK_DIR);
+    const back = deresolvePipeline(resolveConfig(raw, WORK_DIR), WORK_DIR);
     expect(back.tracks[0]!.tasks[0]!.inputs).toEqual(raw.tracks[0]!.tasks[0]!.inputs!);
     expect(back.tracks[0]!.tasks[0]!.outputs).toEqual(raw.tracks[0]!.tasks[0]!.outputs!);
   });
 
-  test('ports with both inputs and outputs round-trip', () => {
-    const raw: RawPipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          tasks: [
-            {
-              id: 'a',
-              prompt: 'hi',
-              ports: {
-                inputs: [{ name: 'city', type: 'string', required: true }],
-                outputs: [{ name: 'temp', type: 'number' }],
-              },
-            },
-          ],
-        },
-      ],
-    };
-    const resolved = resolveConfig(raw, WORK_DIR);
-    const back = deresolvePipeline(resolved, WORK_DIR);
-    expect(back.tracks[0]!.tasks[0]!.ports).toEqual(raw.tracks[0]!.tasks[0]!.ports!);
-  });
-
-  test('ports with only outputs round-trip', () => {
-    const raw: RawPipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          tasks: [
-            {
-              id: 'a',
-              command: 'echo hi',
-              ports: { outputs: [{ name: 'x', type: 'string' }] },
-            },
-          ],
-        },
-      ],
-    };
-    const resolved = resolveConfig(raw, WORK_DIR);
-    const back = deresolvePipeline(resolved, WORK_DIR);
-    expect(back.tracks[0]!.tasks[0]!.ports).toEqual({
-      outputs: [{ name: 'x', type: 'string' }],
-    });
-  });
-
-  test('empty ports ({}) is dropped on deresolve', () => {
-    // YAML round-trip prefers field absence over `ports: {}` so a task
-    // that once declared a port but had it cleared in the editor
-    // doesn't persist a useless empty object in the file.
+  test('empty binding maps are dropped on deresolve', () => {
     const resolved: PipelineConfig = {
       name: 'p',
       tracks: [
         {
           id: 't',
           name: 'T',
-          driver: 'opencode',
-          permissions: { read: true, write: false, execute: false },
-          on_failure: 'skip_downstream',
           tasks: [
             {
               id: 'a',
               name: 'a',
               prompt: 'hi',
-              permissions: { read: true, write: false, execute: false },
-              driver: 'opencode',
-              ports: {},
+              inputs: {},
+              outputs: {},
             },
           ],
         },
       ],
     };
     const back = deresolvePipeline(resolved, WORK_DIR);
-    expect(back.tracks[0]!.tasks[0]!.ports).toBeUndefined();
+    expect(back.tracks[0]!.tasks[0]!.inputs).toBeUndefined();
+    expect(back.tracks[0]!.tasks[0]!.outputs).toBeUndefined();
   });
 
-  test('YAML round-trip via serializePipeline preserves the full ports shape', () => {
+  test('YAML round-trip preserves typed unified binding shape', () => {
     const raw: RawPipelineConfig = {
       name: 'p',
       tracks: [
@@ -230,18 +94,13 @@ describe('deresolvePipeline — ports round-trip', () => {
             {
               id: 'classify',
               prompt: 'pick a bucket',
-              ports: {
-                inputs: [
-                  { name: 'doc', type: 'string', required: true, description: 'Full text' },
-                ],
-                outputs: [
-                  {
-                    name: 'bucket',
-                    type: 'enum',
-                    enum: ['spam', 'ham'],
-                    description: 'Classification',
-                  },
-                ],
+              inputs: { doc: { type: 'string', required: true, description: 'Full text' } },
+              outputs: {
+                bucket: {
+                  type: 'enum',
+                  enum: ['spam', 'ham'],
+                  description: 'Classification',
+                },
               },
             },
           ],
@@ -250,14 +109,11 @@ describe('deresolvePipeline — ports round-trip', () => {
     };
     const yamlText = serializePipeline(raw);
     const parsed = (yaml.load(yamlText) as { pipeline: RawPipelineConfig }).pipeline;
-    expect(parsed.tracks[0]!.tasks[0]!.ports).toEqual(raw.tracks[0]!.tasks[0]!.ports!);
+    expect(parsed.tracks[0]!.tasks[0]!.inputs).toEqual(raw.tracks[0]!.tasks[0]!.inputs!);
+    expect(parsed.tracks[0]!.tasks[0]!.outputs).toEqual(raw.tracks[0]!.tasks[0]!.outputs!);
   });
-});
-
-// ─── parseYaml accepts ports ─────────────────────────────────────────
 
-describe('parseYaml — accepts ports declarations', () => {
-  test('real-world YAML with lightweight bindings parses cleanly', () => {
+  test('real-world YAML with typed bindings parses cleanly', () => {
     const text = `pipeline:
   name: demo
   tracks:
@@ -267,56 +123,27 @@ describe('parseYaml — accepts ports declarations', () => {
         - id: build
           command: bun run build
           outputs:
-            bundlePath: { from: json.bundlePath }
+            bundlePath:
+              from: json.bundlePath
+              type: string
         - id: test
           depends_on: [build]
           command: 'bun test "{{inputs.bundlePath}}"'
           inputs:
             bundlePath:
               from: t.build.outputs.bundlePath
+              type: string
               required: true
 `;
     const config = parseYaml(text);
-    const build = config.tracks[0]!.tasks[0]!;
-    const testTask = config.tracks[0]!.tasks[1]!;
-    expect(build.outputs!.bundlePath).toEqual({ from: 'json.bundlePath' });
-    expect(testTask.inputs!.bundlePath).toEqual({
+    expect(config.tracks[0]!.tasks[0]!.outputs!.bundlePath).toEqual({
+      from: 'json.bundlePath',
+      type: 'string',
+    });
+    expect(config.tracks[0]!.tasks[1]!.inputs!.bundlePath).toEqual({
       from: 't.build.outputs.bundlePath',
+      type: 'string',
       required: true,
     });
   });
-
-  test('real-world YAML with ports parses cleanly', () => {
-    const text = `pipeline:
-  name: demo
-  tracks:
-    - id: t
-      name: Main
-      tasks:
-        - id: plan
-          prompt: Pick a city and id
-          ports:
-            outputs:
-              - name: city
-                type: string
-                description: Target city
-              - name: id
-                type: number
-        - id: fetch
-          depends_on: [plan]
-          command: 'weather.sh --city "{{inputs.city}}" --id {{inputs.id}}'
-          ports:
-            inputs:
-              - { name: city, type: string, required: true }
-              - { name: id, type: number, required: true }
-            outputs:
-              - { name: temp, type: number }
-`;
-    const config = parseYaml(text);
-    const plan = config.tracks[0]!.tasks[0]!;
-    const fetch = config.tracks[0]!.tasks[1]!;
-    expect(plan.ports!.outputs!.map((p) => p.name)).toEqual(['city', 'id']);
-    expect(fetch.ports!.inputs!.map((p) => p.name)).toEqual(['city', 'id']);
-    expect(fetch.ports!.outputs!.map((p) => p.name)).toEqual(['temp']);
-  });
 });