@ziggs-ai/agent-sdk 0.1.3 → 0.1.4

package/src/workflow/WorkflowRuntime.js

@@ -1,63 +0,0 @@
-import { AgentMachine } from './AgentMachine.js';
-
-/**
- * One AgentMachine per lane; dispatches events and waits until parked.
- */
-export class WorkflowRuntime {
-  constructor({ definition, executionCore, services, onSnapshot }) {
-    this.definition = definition;
-    this.executionCore = executionCore;
-    this.services = services;
-    this.onSnapshot = onSnapshot;
-    this.actors = new Map();
-  }
-
-  getOrCreate(laneKey, input = {}) {
-    let machine = this.actors.get(laneKey);
-    if (machine && machine.status === 'active') return machine;
-
-    machine = new AgentMachine({
-      definition: this.definition,
-      executionCore: this.executionCore,
-      services: this.services,
-      input,
-    });
-
-    if (this.onSnapshot) {
-      machine.subscribe(snapshot => {
-        console.log(`[${this.definition.id || 'agent'}] → ${JSON.stringify(snapshot.value)}`);
-        this.onSnapshot(laneKey, snapshot);
-      });
-    }
-
-    this.actors.set(laneKey, machine);
-    return machine;
-  }
-
-  async sendAndWaitForPark({ laneKey, event, timeoutMs = 120_000, machineInput = {} }) {
-    const machine = this.getOrCreate(laneKey, machineInput);
-
-    return new Promise(resolve => {
-      let settled = false;
-
-      const settle = () => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        sub.unsubscribe();
-        resolve();
-      };
-
-      const sub = machine.subscribe(() => {
-        if (machine.isParked) settle();
-      });
-
-      machine.send(event);
-
-      const timer = setTimeout(() => {
-        console.warn(`[WorkflowRuntime] Timed out after ${timeoutMs}ms laneKey=${laneKey}`);
-        settle();
-      }, timeoutMs);
-    });
-  }
-}

package/src/workflow/dsl.js

@@ -1,287 +0,0 @@
-/**
- * Ziggs Agent DSL
- *
- * A small, indentation-based language for describing agents. Parsed at
- * import time into a defineAgent-ready config. No state names, no
- * transitions, no ctx flags — just the agent's intent.
- *
- *   import { agent } from '@ziggs-ai/agent-sdk/dsl';
- *
- *   export default agent`
- *     id        weather-forecaster
- *     role      Weather Forecaster
- *     goal      Deliver real-time forecasts using live APIs
- *     tools     weather-forecast
- *
- *     behavior  service
- *       ask     when details are missing
- *       report  before closing the task
- *   `;
- *
- * Grammar (indentation-sensitive, 2-space blocks):
- *
- *   <program>   ::= <header>* <behavior-block>
- *   <header>    ::= <key> <value>\n
- *   <behavior>  ::= "behavior" <shape> [<arg>]\n <option>*
- *   <option>    ::= <indent> <key> <value>\n
- *
- *   <shape>     ::= "service" | "pipeline" | "map-reduce"
- *                 | "debate" | "voting" | "critic" | "hierarchical"
- *                 | "compose"
- *   <arg>       ::= "of" <int> ("steps"|"rounds"|"chunks"|"voters")
- *
- * Unknown keys and misaligned indentation throw at parse time.
- */
-
-import { defineAgent } from '../ziggs/runtime.js';
-import {
-  listen, propose, execute,
-  plan, dispatch, awaitSubtasks, synthesize,
-  seq, loop, compile, service as serviceFrag,
-} from './motifs.js';
-
-// ── Tokenizer ─────────────────────────────────────────────────────────────
-
-function dedent(src) {
-  const lines = src.split('\n');
-  // Drop leading/trailing blank lines
-  while (lines.length && !lines[0].trim()) lines.shift();
-  while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
-  const indents = lines
-    .filter(l => l.trim())
-    .map(l => l.match(/^ */)[0].length);
-  const base = Math.min(...indents, Infinity);
-  return lines.map(l => l.slice(base));
-}
-
-function tokenize(src) {
-  const lines = dedent(src);
-  const tokens = [];
-  for (let i = 0; i < lines.length; i++) {
-    const raw = lines[i];
-    if (!raw.trim()) { tokens.push({ kind: 'blank', line: i + 1 }); continue; }
-    const indent = raw.match(/^ */)[0].length;
-    if (indent % 2 !== 0) {
-      throw new SyntaxError(`line ${i + 1}: indent must be a multiple of 2 spaces`);
-    }
-    const text = raw.trim();
-    // Split on first run of 2+ spaces OR a single space if key is one word.
-    const m = text.match(/^([\w-]+)\s+(.*)$/);
-    if (!m) {
-      tokens.push({ kind: 'flag', key: text, line: i + 1, depth: indent / 2 });
-      continue;
-    }
-    tokens.push({
-      kind: 'pair',
-      key: m[1].toLowerCase(),
-      value: m[2].trim(),
-      depth: indent / 2,
-      line: i + 1,
-    });
-  }
-  return tokens;
-}
-
-// ── Parser ────────────────────────────────────────────────────────────────
-
-const HEADER_KEYS = new Set(['id', 'role', 'goal', 'context', 'constraints', 'tools', 'model']);
-const SHAPES = new Set([
-  'service', 'pipeline', 'map-reduce', 'debate',
-  'voting', 'critic', 'hierarchical', 'compose',
-]);
-const ARG_WORDS = { steps: 'count', rounds: 'count', chunks: 'count', voters: 'count' };
-
-function parse(tokens) {
-  const config = { headers: {}, behavior: null };
-  let i = 0;
-
-  // Headers (depth 0 key/value pairs before behavior)
-  while (i < tokens.length) {
-    const t = tokens[i];
-    if (t.kind === 'blank') { i++; continue; }
-    if (t.kind !== 'pair' || t.depth !== 0) break;
-    if (t.key === 'behavior') break;
-    if (!HEADER_KEYS.has(t.key)) {
-      throw new SyntaxError(`line ${t.line}: unknown header "${t.key}". Valid: ${[...HEADER_KEYS].join(', ')}`);
-    }
-    config.headers[t.key] = t.value;
-    i++;
-  }
-
-  // Behavior block
-  const bt = tokens[i];
-  if (!bt || bt.key !== 'behavior') {
-    throw new SyntaxError('missing "behavior" block');
-  }
-  config.behavior = parseBehavior(bt, tokens, i);
-  return config;
-}
-
-function parseBehavior(header, tokens, start) {
-  //   behavior  pipeline of 5 steps
-  //     option  value
-  //     option  value
-  const parts = header.value.split(/\s+/);
-  const shape = parts[0];
-  if (!SHAPES.has(shape)) {
-    throw new SyntaxError(`line ${header.line}: unknown shape "${shape}". Valid: ${[...SHAPES].join(', ')}`);
-  }
-  const behavior = { shape, options: {} };
-
-  // Optional "of N <word>" suffix
-  if (parts[1] === 'of') {
-    const n = parseInt(parts[2], 10);
-    const word = parts[3];
-    if (isNaN(n) || !word || !(word in ARG_WORDS)) {
-      throw new SyntaxError(`line ${header.line}: expected "of <n> (steps|rounds|chunks|voters)"`);
-    }
-    behavior.options[ARG_WORDS[word]] = n;
-  }
-
-  // Indented options
-  let i = start + 1;
-  while (i < tokens.length) {
-    const t = tokens[i];
-    if (t.kind === 'blank') { i++; continue; }
-    if (t.depth !== 1) break;
-    if (t.kind === 'pair') {
-      behavior.options[t.key] = t.value;
-    } else {
-      behavior.options[t.key] = true;
-    }
-    i++;
-  }
-  return behavior;
-}
-
-// ── Compiler (DSL → motif fragments → defineAgent config) ────────────────
-
-function compileService({ tool, work, ...rest }, headers) {
-  return serviceFrag({
-    role: headers.role,
-    goal: headers.goal,
-    context: headers.context,
-    constraints: headers.constraints,
-    toolHint: tool || (headers.tools?.split(',')[0]?.trim()),
-  });
-}
-
-function compilePipeline(opts, headers) {
-  return seq(
-    plan({ role: headers.role, goal: headers.goal, maxItems: opts.count ?? 5 }),
-    dispatch({ parallel: false }),
-    awaitSubtasks({ mode: 'one', name: 'awaitingStep' }),
-    synthesize({ role: headers.role }),
-  );
-}
-
-function compileMapReduce(opts, headers) {
-  return seq(
-    plan({ role: headers.role, maxItems: opts.count ?? 8, name: 'splitting' }),
-    dispatch({ parallel: true }),
-    awaitSubtasks({ mode: 'all', name: 'awaitingChunks' }),
-    synthesize({ role: headers.role, name: 'reducing' }),
-  );
-}
-
-function compileDebate(opts, headers) {
-  const rounds = opts.count ?? 3;
-  return seq(
-    plan({ role: headers.role, maxItems: 4 }),
-    loop(rounds,
-      dispatch({ parallel: true, name: 'round' }),
-      awaitSubtasks({ mode: 'all', name: 'collecting' }),
-    ),
-    synthesize({ role: headers.role, name: 'concluding' }),
-  );
-}
-
-function compileVoting(opts, headers) {
-  return seq(
-    plan({ role: headers.role, maxItems: opts.count ?? 5 }),
-    dispatch({ parallel: true, name: 'polling' }),
-    awaitSubtasks({ mode: 'all', name: 'counting' }),
-    synthesize({ role: headers.role, name: 'deciding', goal: 'Tally votes and announce the decision.' }),
-  );
-}
-
-function compileCritic(opts, headers) {
-  const rounds = opts.count ?? 2;
-  return seq(
-    plan({ role: headers.role, maxItems: 2 }),
-    loop(rounds,
-      dispatch({ parallel: false, name: 'drafting' }),
-      awaitSubtasks({ mode: 'one', name: 'reviewing' }),
-    ),
-    synthesize({ role: headers.role }),
-  );
-}
-
-function compileHierarchical(opts, headers) {
-  return seq(
-    plan({ role: headers.role, maxItems: opts.count ?? 5, goal: 'Choose lieutenants and assign sub-goals.' }),
-    dispatch({ parallel: true, name: 'delegating' }),
-    awaitSubtasks({ mode: 'all', name: 'awaitingReports' }),
-    synthesize({ role: headers.role }),
-  );
-}
-
-const SHAPE_COMPILERS = {
-  service: compileService,
-  pipeline: compilePipeline,
-  'map-reduce': compileMapReduce,
-  debate: compileDebate,
-  voting: compileVoting,
-  critic: compileCritic,
-  hierarchical: compileHierarchical,
-};
-
-// ── Public API: tagged template ───────────────────────────────────────────
-
-const EXPR_TOKEN = (i) => `__EXPR_${i}__`;
-
-export function agent(strings, ...exprs) {
-  // Inline each interpolation as a stable placeholder so we can look up the
-  // real JS value (e.g. a defineTool instance) after text parsing.
-  let src = strings[0];
-  for (let i = 0; i < exprs.length; i++) src += EXPR_TOKEN(i) + strings[i + 1];
-
-  const tokens = tokenize(src);
-  const { headers, behavior } = parse(tokens);
-
-  // Resolve interpolated tool references.
-  const rawTools = (headers.tools ?? '').split(',').map(s => s.trim()).filter(Boolean);
-  headers.__tools = rawTools.map(ref => {
-    const m = ref.match(/^__EXPR_(\d+)__$/);
-    return m ? exprs[+m[1]] : ref;
-  });
-
-  if (!headers.id) throw new SyntaxError('missing required header "id"');
-  if (!headers.role) throw new SyntaxError('missing required header "role"');
-
-  const compiler = SHAPE_COMPILERS[behavior.shape];
-  const fragment = compiler(behavior.options, headers);
-  const { initial, states } = compile(fragment);
-
-  // Tools come from interpolation (${toolInstance}) — any non-string value in
-  // the tools header is a real defineTool() instance. String values are
-  // unresolved names and are dropped here (service agents that need a tool
-  // must interpolate it).
-  const tools = (headers.__tools ?? []).filter(t => t && typeof t === 'object');
-
-  return defineAgent({
-    agentId: headers.id,
-    description: headers.role,
-    specialization: headers.goal,
-    initial,
-    states,
-    tools,
-    ...(headers.model && { services: { llm: { model: headers.model } } }),
-  });
-}
-
-// Escape hatch: parse without compiling, for testing/tooling.
-export function parseDsl(strings, ...exprs) {
-  const src = Array.isArray(strings) ? String.raw({ raw: strings }, ...exprs) : strings;
-  return parse(tokenize(src));
-}