@pixerate/editor 0.140.4 → 0.142.1

package/dist/chunk-X2HQP7DF.cjs

@@ -0,0 +1,408 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+var _chunkUJGAA6AKcjs = require('./chunk-UJGAA6AK.cjs');
+
+// src/tools/playback.ts
+var ARG_KINDS = {
+  nodeId: "node",
+  edgeId: "edge",
+  layerId: "layer",
+  clipId: "clip",
+  trackId: "track",
+  seriesId: "series",
+  parameterId: "parameter",
+  keyframeId: "keyframe",
+  shapeId: "shape"
+};
+function pushRef(out, kind, id) {
+  if (typeof id !== "string" || !id) return;
+  if (!out.some((r) => r.kind === kind && r.id === id)) out.push({ kind, id });
+}
+function playbackRefsFromArgs(args, defaultKind = "item") {
+  const out = [];
+  const visit = (value, depth) => {
+    if (!value || typeof value !== "object" || Array.isArray(value) || depth > 1) return;
+    const record = value;
+    pushRef(out, defaultKind, record.id);
+    if (Array.isArray(record.ids)) for (const id of record.ids) pushRef(out, defaultKind, id);
+    for (const [key, kind] of Object.entries(ARG_KINDS)) {
+      pushRef(out, kind, record[key]);
+      const many = record[`${key}s`];
+      if (Array.isArray(many)) for (const id of many) pushRef(out, kind, id);
+    }
+    pushRef(out, "cell", record.range);
+    pushRef(out, "cell", record.cell);
+    visit(record.params, depth + 1);
+  };
+  visit(args, 0);
+  return out;
+}
+function playbackRefsFromResult(value, defaultKind = "item") {
+  const out = [];
+  const visit = (v, depth) => {
+    if (!v || typeof v !== "object" || depth > 2) return;
+    if (Array.isArray(v)) {
+      for (const item of v) if (item && typeof item === "object") pushRef(out, defaultKind, item.id);
+      return;
+    }
+    const record = v;
+    if (Array.isArray(record.content) && record.structuredContent) return visit(record.structuredContent, depth);
+    pushRef(out, defaultKind, record.id);
+    if (Array.isArray(record.ids)) for (const id of record.ids) pushRef(out, defaultKind, id);
+    if (record.node && typeof record.node === "object") pushRef(out, "node", record.node.id);
+    pushRef(out, "layer", record.layerId);
+    if (record.layer && typeof record.layer === "object") pushRef(out, "layer", record.layer.id);
+    const created = record.created;
+    if (Array.isArray(created)) visit(created, depth + 1);
+    else if (created && typeof created === "object") {
+      const c = created;
+      for (const n of _nullishCoalesce(c.nodes, () => ( []))) pushRef(out, "node", _optionalChain([n, 'optionalAccess', _ => _.id]));
+      for (const e of _nullishCoalesce(c.edges, () => ( []))) pushRef(out, "edge", _optionalChain([e, 'optionalAccess', _2 => _2.id]));
+    }
+    if (record.result && typeof record.result === "object") visit(record.result, depth + 1);
+  };
+  visit(value, 0);
+  return out;
+}
+function derivePlaybackSteps(args, defaultKind) {
+  const refs = playbackRefsFromArgs(args, defaultKind).slice(0, 8);
+  if (!refs.length) return [{ type: "commit" }];
+  return [...refs.map((ref) => ({ type: "target", ref })), { type: "press" }, { type: "release" }, { type: "commit" }];
+}
+function readingTime(text) {
+  return Math.min(2200, Math.max(600, text.length * 65));
+}
+function unionRects(rects) {
+  const list = rects.filter((r) => !!r);
+  if (!list.length) return null;
+  const x = Math.min(...list.map((r) => r.x));
+  const y = Math.min(...list.map((r) => r.y));
+  return { x, y, width: Math.max(...list.map((r) => r.x + r.width)) - x, height: Math.max(...list.map((r) => r.y + r.height)) - y };
+}
+function normalizePlan(plan) {
+  if (!plan) return null;
+  if (Array.isArray(plan)) return plan.length ? { steps: plan } : null;
+  return _optionalChain([plan, 'access', _3 => _3.steps, 'optionalAccess', _4 => _4.length]) || plan.surface || plan.readOnly !== void 0 ? plan : null;
+}
+var isErrorResult = (value) => !!value && typeof value === "object" && value.isError === true;
+var center = (r) => ({ x: r.x + r.width / 2, y: r.y + r.height / 2 });
+var finiteRect = (r) => r && [r.x, r.y, r.width, r.height].every(Number.isFinite) ? r : null;
+var GLANCE_STEPS = /* @__PURE__ */ new Set(["move", "target", "focus", "say", "wait", "commit"]);
+var AgentPlayback = (_class = class {
+  /** 1 = natural pace; `Infinity` plays nothing (calls run instantly). Takes effect on the next step. */
+  
+  
+  
+  
+  
+  __init() {this.surfaces = /* @__PURE__ */ new Map()}
+  __init2() {this.actors = /* @__PURE__ */ new Map()}
+  __init3() {this.recordings = /* @__PURE__ */ new Set()}
+  __init4() {this.installed = /* @__PURE__ */ new WeakSet()}
+  __init5() {this.listeners = /* @__PURE__ */ new Set()}
+  __init6() {this.generation = 0}
+  __init7() {this.running = 0}
+  __init8() {this.calls = 0}
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);
+    this.clock = _nullishCoalesce(options.clock, () => ( _chunkUJGAA6AKcjs.realPresenceClock));
+    this.speed = _nullishCoalesce(options.speed, () => ( 1));
+    this.reads = _nullishCoalesce(options.reads, () => ( "glance"));
+    this.linger = _nullishCoalesce(options.linger, () => ( 1500));
+    this.defaultActor = _nullishCoalesce(options.actor, () => ( { id: "agent", name: "Agent" }));
+  }
+  /** The registry middleware that plays each call. */
+  __init9() {this.middleware = (call, next) => this.perform(call, next)}
+  /** Adds the middleware to `registry` once (later calls with the same registry do nothing). */
+  install(registry) {
+    if (this.installed.has(registry)) return;
+    this.installed.add(registry);
+    registry.use(this.middleware);
+  }
+  /** Whether a performance is playing now (e.g. to make the editor read-only meanwhile). */
+  get active() {
+    return this.running > 0;
+  }
+  /** Called when `active` changes. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Attaches a surface under a provider id (or the id providers name as `playbackSurface`). */
+  attach(id, surface) {
+    this.surfaces.set(id, surface);
+    return () => {
+      if (this.surfaces.get(id) !== surface) return;
+      this.surfaces.delete(id);
+      for (const actor of this.actors.values()) if (actor.surface === id) actor.surface = void 0;
+    };
+  }
+  /** The surface attached under `id`. */
+  surface(id) {
+    return this.surfaces.get(id);
+  }
+  /** Shows `text` in the actor's bubble on the surface it last worked on (until its next step). */
+  say(text, options = {}) {
+    const actor = this.actorState(options.actor);
+    const surface = actor.surface ? this.surfaces.get(actor.surface) : void 0;
+    if (_optionalChain([surface, 'optionalAccess', _5 => _5.presence, 'access', _6 => _6.get, 'call', _7 => _7(actor.info.id)])) surface.presence.set({ id: actor.info.id, message: text });
+  }
+  /** Finishes every running performance at once (the calls still run and keep their results). */
+  stop() {
+    this.generation++;
+  }
+  /** Collects every step played from now on (for tests). */
+  record() {
+    const list = [];
+    this.recordings.add(list);
+    return list;
+  }
+  actorState(info) {
+    const base = _nullishCoalesce(info, () => ( this.defaultActor));
+    let actor = this.actors.get(base.id);
+    if (!actor) {
+      actor = { info: { ...base, color: _nullishCoalesce(base.color, () => ( _chunkUJGAA6AKcjs.PRESENCE_COLORS[this.actors.size % _chunkUJGAA6AKcjs.PRESENCE_COLORS.length])) }, queue: Promise.resolve(), version: 0 };
+      this.actors.set(base.id, actor);
+    } else if (_optionalChain([info, 'optionalAccess', _8 => _8.name]) && info.name !== actor.info.name) actor.info = { ...actor.info, name: info.name };
+    return actor;
+  }
+  enqueue(actor, run) {
+    const result = actor.queue.then(run);
+    actor.queue = result.catch(() => void 0);
+    return result;
+  }
+  surfaceFor(provider, hint) {
+    for (const id of [hint, provider.playbackSurface, provider.id, provider.namespace]) {
+      const surface = id ? this.surfaces.get(id) : void 0;
+      if (id && surface) return [id, surface];
+    }
+    return null;
+  }
+  async perform(call, next) {
+    const tool = call.tool;
+    if (tool.playback === false || !Number.isFinite(this.speed)) return next();
+    const actor = this.actorState(call.context.actor);
+    if (tool.playback === "self") return this.enqueue(actor, next);
+    const fallback = this.surfaceFor(call.provider);
+    let planned = null;
+    if (tool.plan) {
+      try {
+        const state = {
+          surfaceId: _nullishCoalesce(_optionalChain([fallback, 'optionalAccess', _9 => _9[0]]), () => ( null)),
+          locate: (ref) => _nullishCoalesce(_optionalChain([fallback, 'optionalAccess', _10 => _10[1], 'access', _11 => _11.locate, 'optionalCall', _12 => _12(ref)]), () => ( null))
+        };
+        planned = normalizePlan(tool.plan(call.args, state));
+      } catch (e2) {
+        planned = null;
+      }
+    }
+    const readOnly = _nullishCoalesce(_optionalChain([planned, 'optionalAccess', _13 => _13.readOnly]), () => ( _optionalChain([tool, 'access', _14 => _14.annotations, 'optionalAccess', _15 => _15.readOnlyHint]) === true));
+    if (readOnly && this.reads === "skip") return next();
+    const found = this.surfaceFor(call.provider, _optionalChain([planned, 'optionalAccess', _16 => _16.surface]));
+    if (!found) return next();
+    const [surfaceId, surface] = found;
+    const steps = _optionalChain([planned, 'optionalAccess', _17 => _17.steps, 'optionalAccess', _18 => _18.length]) ? planned.steps : derivePlaybackSteps(call.args, surface.defaultKind);
+    const glance = readOnly && this.reads === "glance";
+    const played = glance ? steps.filter((s) => GLANCE_STEPS.has(s.type)) : steps;
+    if (!played.some((s) => s.type !== "commit")) return next();
+    return this.enqueue(actor, async () => {
+      if (surface.visible && !surface.visible()) {
+        await _optionalChain([surface, 'access', _19 => _19.reveal, 'optionalCall', _20 => _20()]);
+        if (surface.visible && !surface.visible()) return next();
+      }
+      return this.play({ call, next, actor, surfaceId, surface, steps: played, readOnly, glance });
+    });
+  }
+  async play(run) {
+    const { call, next, actor, surfaceId, surface, readOnly } = run;
+    const id = actor.info.id;
+    const gen = this.generation;
+    const instant = () => gen !== this.generation || !Number.isFinite(this.speed);
+    const pace = () => Math.max(0.1, this.speed) * (run.glance ? 1.6 : 1);
+    const wait = (ms) => instant() || ms <= 0 ? Promise.resolve() : this.clock.wait(ms / pace());
+    const presence = surface.presence;
+    const locate = (ref) => finiteRect(_nullishCoalesce(_optionalChain([surface, 'access', _21 => _21.locate, 'optionalCall', _22 => _22(ref.kind === "item" ? { kind: _nullishCoalesce(surface.defaultKind, () => ( "item")), id: ref.id } : ref)]), () => ( null)));
+    const record = (step) => {
+      for (const list of this.recordings) list.push({ actor: id, surface: surfaceId, tool: call.name, step });
+    };
+    this.running++;
+    if (this.running === 1) this.listeners.forEach((l) => l());
+    try {
+      if (actor.surface && actor.surface !== surfaceId) _optionalChain([this, 'access', _23 => _23.surfaces, 'access', _24 => _24.get, 'call', _25 => _25(actor.surface), 'optionalAccess', _26 => _26.presence, 'access', _27 => _27.remove, 'call', _28 => _28(id)]);
+      if (!presence.get(id)) {
+        const bounds = _nullishCoalesce(_optionalChain([surface, 'access', _29 => _29.bounds, 'optionalCall', _30 => _30()]), () => ( null));
+        let at = actor.viewport && surface.fromViewport ? surface.fromViewport(actor.viewport) : null;
+        if (at && bounds) at = { x: Math.min(bounds.x + bounds.width, Math.max(bounds.x, at.x)), y: Math.min(bounds.y + bounds.height, Math.max(bounds.y, at.y)) };
+        at ??= bounds ? { x: bounds.x + bounds.width - 48, y: bounds.y + 32 } : null;
+        if (!at) {
+          const first = run.steps.find((s) => s.type === "move" || s.type === "target" || s.type === "drag");
+          const rect = _optionalChain([first, 'optionalAccess', _31 => _31.type]) === "target" ? locate(first.ref) : null;
+          at = first && first.type !== "target" ? first.to : rect ? center(rect) : { x: 0, y: 0 };
+        }
+        presence.set({ id, name: _nullishCoalesce(actor.info.name, () => ( id)), color: actor.info.color, x: at.x, y: at.y, pressed: false });
+      } else presence.set({ id, name: _nullishCoalesce(actor.info.name, () => ( id)), color: actor.info.color });
+      actor.surface = surfaceId;
+      actor.version++;
+      const argRefs = playbackRefsFromArgs(call.args, surface.defaultKind);
+      if (!readOnly) _optionalChain([surface, 'access', _32 => _32.beginGesture, 'optionalCall', _33 => _33(`agent:${id}:${++this.calls}`)]);
+      let result;
+      let committed = false;
+      try {
+        for (const step of run.steps) {
+          record(step);
+          if (step.type === "commit") {
+            if (committed) continue;
+            committed = true;
+            result = await next();
+            continue;
+          }
+          if (step.type === "open") {
+            if (!surface.open) continue;
+            const rect = locate(step.ref);
+            if (rect) {
+              await this.glide(presence, id, { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 }, step.ms, instant);
+              presence.set({ id, pressed: true });
+              await wait(90);
+            }
+            await surface.open(step.ref);
+            presence.set({ id, pressed: false });
+            await wait(220);
+            continue;
+          }
+          await this.step(presence, locate, id, step, wait, instant);
+        }
+        if (!committed) {
+          record({ type: "commit" });
+          result = await next();
+        }
+      } catch (error) {
+        presence.set({ id, pressed: false, message: `\u2717 ${error instanceof Error ? error.message : String(error)}`.slice(0, 140) });
+        await wait(900);
+        throw error;
+      } finally {
+        if (!readOnly) _optionalChain([surface, 'access', _34 => _34.endGesture, 'optionalCall', _35 => _35()]);
+        presence.set({ id, pressed: false });
+      }
+      if (isErrorResult(result)) {
+        const text = _nullishCoalesce(_optionalChain([result, 'access', _36 => _36.content, 'optionalAccess', _37 => _37.find, 'call', _38 => _38((c) => c.type === "text"), 'optionalAccess', _39 => _39.text]), () => ( "The tool failed."));
+        presence.set({ id, message: `\u2717 ${text}`.slice(0, 140) });
+        await wait(900);
+      } else if (!readOnly) {
+        const known = new Set(argRefs.map((r) => `${r.kind}:${r.id}`));
+        const fresh = playbackRefsFromResult(result, surface.defaultKind).filter((r) => !known.has(`${r.kind}:${r.id}`));
+        const rect = unionRects(fresh.slice(0, 16).map(locate));
+        if (rect) {
+          const step = { type: "focus", rect };
+          record(step);
+          presence.set({ id, focus: rect });
+          await wait(450);
+        }
+      }
+      presence.set({ id, message: void 0, focus: void 0 });
+      const here = presence.get(id);
+      if (here && surface.toViewport) actor.viewport = surface.toViewport({ x: here.x, y: here.y });
+      this.scheduleLinger(actor, surface);
+      return result;
+    } finally {
+      this.running--;
+      if (this.running === 0) this.listeners.forEach((l) => l());
+    }
+  }
+  scheduleLinger(actor, surface) {
+    if (this.linger <= 0) return;
+    const version = actor.version;
+    void this.clock.wait(this.linger).then(() => {
+      if (actor.version !== version) return;
+      surface.presence.remove(actor.info.id);
+      for (const [sid, s] of this.surfaces) if (s === surface && actor.surface === sid) actor.surface = void 0;
+    });
+  }
+  async step(presence, locate, id, step, wait, instant) {
+    switch (step.type) {
+      case "move":
+        return this.glide(presence, id, step.to, step.ms, instant);
+      case "drag":
+        presence.set({ id, pressed: true });
+        return this.glide(presence, id, step.to, step.ms, instant);
+      case "target": {
+        const rect = locate(step.ref);
+        if (!rect) return;
+        await this.glide(presence, id, center(rect), step.ms, instant);
+        presence.set({ id, focus: rect });
+        return;
+      }
+      case "focus":
+        presence.set({ id, focus: _nullishCoalesce(step.rect, () => ( void 0)) });
+        return;
+      case "say":
+        presence.set({ id, message: step.text });
+        return wait(_nullishCoalesce(step.ms, () => ( readingTime(step.text))));
+      case "press":
+        presence.set({ id, pressed: true });
+        return wait(90);
+      case "release":
+        presence.set({ id, pressed: false });
+        return wait(60);
+      case "type": {
+        const total = _nullishCoalesce(step.ms, () => ( Math.min(900, 40 * step.text.length + 150)));
+        if (instant() || !(total > 0) || !Number.isFinite(total)) {
+          presence.set({ id, message: step.text });
+          return;
+        }
+        const start = this.clock.now();
+        for (; ; ) {
+          const t = Math.min(1, (this.clock.now() - start) / (total / Math.max(0.1, this.speed)));
+          presence.set({ id, message: step.text.slice(0, Math.max(1, Math.round(step.text.length * t))) });
+          if (t >= 1 || instant()) break;
+          await this.clock.wait(16);
+        }
+        presence.set({ id, message: step.text });
+        return;
+      }
+      case "wait":
+        return wait(step.ms);
+    }
+  }
+  /** Glides along a slight arc with ease-out, by elapsed time (fewer frames in a throttled tab, never longer). */
+  async glide(presence, id, to, ms, instant) {
+    if (!Number.isFinite(to.x) || !Number.isFinite(to.y)) return;
+    const a = presence.get(id);
+    const from = a && Number.isFinite(a.x) && Number.isFinite(a.y) ? { x: a.x, y: a.y } : to;
+    const dist = Math.hypot(to.x - from.x, to.y - from.y);
+    const duration = (_nullishCoalesce(ms, () => ( Math.min(900, 260 + dist * 0.5)))) / Math.max(0.1, this.speed);
+    if (instant() || dist < 1 || !(duration > 0) || !Number.isFinite(duration)) {
+      presence.set({ id, x: to.x, y: to.y });
+      return;
+    }
+    const bend = Math.min(60, dist * 0.12);
+    const ctrl = { x: (from.x + to.x) / 2 - (to.y - from.y) / dist * bend, y: (from.y + to.y) / 2 + (to.x - from.x) / dist * bend };
+    const start = this.clock.now();
+    for (; ; ) {
+      const t = Math.min(1, (this.clock.now() - start) / duration);
+      const e = 1 - Math.pow(1 - t, 3);
+      const u = 1 - e;
+      presence.set({ id, x: u * u * from.x + 2 * u * e * ctrl.x + e * e * to.x, y: u * u * from.y + 2 * u * e * ctrl.y + e * e * to.y });
+      if (t >= 1) break;
+      if (instant()) {
+        presence.set({ id, x: to.x, y: to.y });
+        break;
+      }
+      await this.clock.wait(16);
+    }
+  }
+}, _class);
+function createAgentPlayback(options = {}) {
+  return new AgentPlayback(options);
+}
+
+
+
+
+
+
+
+
+
+exports.playbackRefsFromArgs = playbackRefsFromArgs; exports.playbackRefsFromResult = playbackRefsFromResult; exports.derivePlaybackSteps = derivePlaybackSteps; exports.readingTime = readingTime; exports.unionRects = unionRects; exports.AgentPlayback = AgentPlayback; exports.createAgentPlayback = createAgentPlayback;

package/dist/chunk-XH32BATE.cjs

@@ -0,0 +1,68 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkX2HQP7DFcjs = require('./chunk-X2HQP7DF.cjs');
+
+// src/tools/script.ts
+function toolResultValue(result) {
+  if (result.structuredContent) return result.structuredContent;
+  const text = result.content.find((b) => b.type === "text");
+  if (!_optionalChain([text, 'optionalAccess', _ => _.text])) return void 0;
+  try {
+    return JSON.parse(text.text);
+  } catch (e) {
+    return text.text;
+  }
+}
+function toolResultError(result) {
+  const text = result.content.find((b) => b.type === "text");
+  return _nullishCoalesce(_optionalChain([text, 'optionalAccess', _2 => _2.text]), () => ( "The tool failed."));
+}
+var realWait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function runToolScript(source, script, options = {}) {
+  const control = _nullishCoalesce(options.control, () => ( { speed: 1, stopped: false }));
+  const wait = _nullishCoalesce(options.wait, () => ( realWait));
+  const pause = (ms) => Number.isFinite(control.speed) ? wait(ms / Math.max(0.1, control.speed)) : Promise.resolve();
+  const emit = _nullishCoalesce(options.onEvent, () => ( (() => {
+  })));
+  const ctx = { results: {}, last: void 0 };
+  const finish = (ok) => {
+    if (control.stopped) _optionalChain([options, 'access', _3 => _3.playback, 'optionalAccess', _4 => _4.stop, 'call', _5 => _5()]);
+    emit({ type: "done", ok, stopped: control.stopped });
+    return { ok, ctx };
+  };
+  for (let i = 0; i < script.steps.length; i++) {
+    if (control.stopped) return finish(false);
+    const step = script.steps[i];
+    if (step.say) {
+      emit({ type: "say", step: i, text: step.say });
+      _optionalChain([options, 'access', _6 => _6.playback, 'optionalAccess', _7 => _7.say, 'call', _8 => _8(step.say, options.actor ? { actor: options.actor } : {})]);
+      await pause(_chunkX2HQP7DFcjs.readingTime.call(void 0, step.say));
+    }
+    if (!step.tool) continue;
+    if (control.stopped) return finish(false);
+    let args;
+    try {
+      args = typeof step.args === "function" ? step.args(ctx) : _nullishCoalesce(step.args, () => ( {}));
+    } catch (error) {
+      emit({ type: "error", step: i, message: error instanceof Error ? error.message : String(error) });
+      return finish(false);
+    }
+    emit({ type: "call", step: i, tool: step.tool, args });
+    const result = await source.callTool(step.tool, args, options.actor ? { actor: options.actor } : {});
+    emit({ type: "result", step: i, tool: step.tool, result });
+    if (result.isError) {
+      emit({ type: "error", step: i, message: toolResultError(result) });
+      return finish(false);
+    }
+    ctx.last = toolResultValue(result);
+    if (step.as) ctx.results[step.as] = ctx.last;
+    await pause(350);
+  }
+  return finish(true);
+}
+
+
+
+
+
+exports.toolResultValue = toolResultValue; exports.toolResultError = toolResultError; exports.runToolScript = runToolScript;

package/dist/{chunk-HDK3T2QS.cjs → chunk-Y4BWZB6J.cjs}

@@ -413,7 +413,7 @@ function readTools(provider) {
   return typeof provider.tools === "function" ? provider.tools() : provider.tools;
 }
 function toDefinition2(name, tool) {
-  const { handler: _handler, name: _name, ...rest } = tool;
+  const { handler: _handler, name: _name, plan: _plan, playback: _playback, ...rest } = tool;
   return { name, ...rest };
 }
 function errorResult(error) {
@@ -442,10 +442,11 @@ var ToolRegistry = (_class2 = class {
   __init7() {this.capabilities = { tools: { listChanged: true } }}
   __init8() {this.entries = []}
   __init9() {this.listeners = /* @__PURE__ */ new Set()}
+  __init10() {this.middleware = []}
   
-  __init10() {this.timer = null}
+  __init11() {this.timer = null}
   
-  constructor(options = {}) {;_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);
+  constructor(options = {}) {;_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);
     this.options = {
       namespaces: _nullishCoalesce(options.namespaces, () => ( "always")),
       onCollision: _nullishCoalesce(options.onCollision, () => ( "namespace")),
@@ -502,6 +503,17 @@ var ToolRegistry = (_class2 = class {
     this.notifyListChanged();
     return true;
   }
+  /**
+   * Adds a middleware that wraps every tool call (first added runs outermost), e.g. agent
+   * playback's `playback.middleware`. Returns a function that removes it.
+   */
+  use(middleware) {
+    this.middleware.push(middleware);
+    return () => {
+      const index = this.middleware.indexOf(middleware);
+      if (index !== -1) this.middleware.splice(index, 1);
+    };
+  }
   /** Registered provider ids in registration order. */
   providerIds() {
     return this.entries.map((e) => e.provider.id);
@@ -609,11 +621,16 @@ var ToolRegistry = (_class2 = class {
       }
     }
     try {
-      const value = await found.tool.handler(input, {
+      const context = {
         name,
         providerId: found.provider.id,
-        signal: options.signal
-      });
+        signal: options.signal,
+        ...options.actor ? { actor: options.actor } : {}
+      };
+      const call = { name, tool: found.tool, provider: found.provider, args: input, context };
+      const chain = [...this.middleware];
+      const run = async (i) => i < chain.length ? chain[i](call, () => run(i + 1)) : found.tool.handler(call.args, context);
+      const value = await run(0);
       return toToolResult(value);
     } catch (error) {
       return errorResult({
@@ -896,6 +913,7 @@ function createMcpServer(registry, options) {
   };
   const readSkillPath = (path) => _nullishCoalesce(_optionalChain([skillFiles, 'optionalAccess', _24 => _24[path]]), () => ( _optionalChain([skillFiles, 'optionalAccess', _25 => _25[`./${path}`]])));
   let initialized = false;
+  let actor;
   let unsubscribe = null;
   const running = /* @__PURE__ */ new Map();
   const startNotifications = () => {
@@ -909,6 +927,10 @@ function createMcpServer(registry, options) {
     const params = _nullishCoalesce(request.params, () => ( {}));
     switch (request.method) {
       case "initialize": {
+        const client = params.clientInfo;
+        if (client && typeof client.name === "string" && client.name) {
+          actor = { id: `mcp:${client.name}`, name: typeof client.title === "string" && client.title ? client.title : client.name };
+        }
         const instructions = typeof options.instructions === "function" ? options.instructions(registry) : options.instructions;
         const requested = String(_nullishCoalesce(params.protocolVersion, () => ( "")));
         const protocolVersion = MCP_PROTOCOL_VERSIONS.includes(requested) ? requested : MCP_PROTOCOL_VERSIONS[0];
@@ -951,7 +973,7 @@ function createMcpServer(registry, options) {
         const controller = new AbortController();
         if (!isNotification) running.set(id, controller);
         try {
-          const result = await registry.callTool(name, _nullishCoalesce(args, () => ( {})), { signal: controller.signal });
+          const result = await registry.callTool(name, _nullishCoalesce(args, () => ( {})), { signal: controller.signal, ...actor ? { actor } : {} });
           if (controller.signal.aborted) return null;
           return { jsonrpc: "2.0", id, result };
         } finally {

package/dist/chunk-Y6SGC6KO.js

@@ -0,0 +1,68 @@
+import {
+  readingTime
+} from "./chunk-54GVEVXS.js";
+
+// src/tools/script.ts
+function toolResultValue(result) {
+  if (result.structuredContent) return result.structuredContent;
+  const text = result.content.find((b) => b.type === "text");
+  if (!text?.text) return void 0;
+  try {
+    return JSON.parse(text.text);
+  } catch {
+    return text.text;
+  }
+}
+function toolResultError(result) {
+  const text = result.content.find((b) => b.type === "text");
+  return text?.text ?? "The tool failed.";
+}
+var realWait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function runToolScript(source, script, options = {}) {
+  const control = options.control ?? { speed: 1, stopped: false };
+  const wait = options.wait ?? realWait;
+  const pause = (ms) => Number.isFinite(control.speed) ? wait(ms / Math.max(0.1, control.speed)) : Promise.resolve();
+  const emit = options.onEvent ?? (() => {
+  });
+  const ctx = { results: {}, last: void 0 };
+  const finish = (ok) => {
+    if (control.stopped) options.playback?.stop();
+    emit({ type: "done", ok, stopped: control.stopped });
+    return { ok, ctx };
+  };
+  for (let i = 0; i < script.steps.length; i++) {
+    if (control.stopped) return finish(false);
+    const step = script.steps[i];
+    if (step.say) {
+      emit({ type: "say", step: i, text: step.say });
+      options.playback?.say(step.say, options.actor ? { actor: options.actor } : {});
+      await pause(readingTime(step.say));
+    }
+    if (!step.tool) continue;
+    if (control.stopped) return finish(false);
+    let args;
+    try {
+      args = typeof step.args === "function" ? step.args(ctx) : step.args ?? {};
+    } catch (error) {
+      emit({ type: "error", step: i, message: error instanceof Error ? error.message : String(error) });
+      return finish(false);
+    }
+    emit({ type: "call", step: i, tool: step.tool, args });
+    const result = await source.callTool(step.tool, args, options.actor ? { actor: options.actor } : {});
+    emit({ type: "result", step: i, tool: step.tool, result });
+    if (result.isError) {
+      emit({ type: "error", step: i, message: toolResultError(result) });
+      return finish(false);
+    }
+    ctx.last = toolResultValue(result);
+    if (step.as) ctx.results[step.as] = ctx.last;
+    await pause(350);
+  }
+  return finish(true);
+}
+
+export {
+  toolResultValue,
+  toolResultError,
+  runToolScript
+};