@hraness/dawg 0.6.0 → 0.7.0

package/src/agent/portable-schema.ts

@@ -0,0 +1,80 @@
+/**
+ * Tool parameter schemas as every provider accepts them.
+ *
+ * dawg writes unions as `type: ["array", "string"]` with `items` beside it.
+ * OpenAI and Anthropic accept that, but Gemini (through the AI Gateway)
+ * rewrites the union to `anyOf` and leaves `items` outside, then rejects the
+ * whole request, so no Gemini model could run a turn. Here each union
+ * becomes an `anyOf` whose branches carry only their own keywords, and an
+ * array branch always has `items`.
+ */
+
+type Schema = Record<string, unknown>;
+
+/** Keywords that belong to one JSON type's branch of a union. */
+const BRANCH_KEYWORDS: Readonly<Record<string, readonly string[]>> = {
+  array: ["items", "minItems", "maxItems"],
+  object: ["properties", "required", "additionalProperties"],
+  string: ["enum", "minLength", "maxLength", "pattern"],
+  number: ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"],
+  integer: ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"],
+};
+const ALL_BRANCH_KEYWORDS = new Set(Object.values(BRANCH_KEYWORDS).flat());
+
+/** Items for an array branch that declared none: any scalar. */
+const ANY_SCALAR_ITEMS: Schema = {
+  anyOf: [{ type: "number" }, { type: "string" }, { type: "boolean" }],
+};
+
+function isSchema(value: unknown): value is Schema {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function branch(type: string, schema: Schema): Schema {
+  const out: Schema = { type };
+  for (const key of BRANCH_KEYWORDS[type] ?? []) {
+    if (!(key in schema)) continue;
+    const value = schema[key];
+    // An enum only constrains the branch whose type its values have.
+    if (key === "enum" && Array.isArray(value)) {
+      const kept = value.filter((v) => typeof v === "string");
+      if (kept.length > 0) out.enum = kept;
+      continue;
+    }
+    out[key] = value;
+  }
+  if (type === "array" && out.items === undefined) out.items = ANY_SCALAR_ITEMS;
+  return portableSchema(out);
+}
+
+/** A copy of `schema` with every type union rewritten as `anyOf`. */
+export function portableSchema(schema: unknown): Schema {
+  if (!isSchema(schema)) return schema as Schema;
+  const out: Schema = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "properties" && isSchema(value)) {
+      out.properties = Object.fromEntries(
+        Object.entries(value).map(([name, sub]) => [name, portableSchema(sub)]),
+      );
+    } else if (
+      (key === "items" || key === "additionalProperties") &&
+      isSchema(value)
+    ) {
+      out[key] = portableSchema(value);
+    } else if ((key === "anyOf" || key === "oneOf") && Array.isArray(value)) {
+      out[key] = value.map(portableSchema);
+    } else {
+      out[key] = value;
+    }
+  }
+  if (Array.isArray(out.type)) {
+    const types = out.type as string[];
+    const rest: Schema = {};
+    for (const [key, value] of Object.entries(out))
+      if (key !== "type" && !ALL_BRANCH_KEYWORDS.has(key)) rest[key] = value;
+    return { ...rest, anyOf: types.map((type) => branch(type, out)) };
+  }
+  if (out.type === "array" && out.items === undefined)
+    out.items = ANY_SCALAR_ITEMS;
+  return out;
+}

package/src/agent/preview-tool.ts

@@ -23,6 +23,7 @@ import {
 } from "../audio/preview.ts";
 import { renderScorePcm, type RenderedAudio } from "../audio/wav.ts";
 import type { ScoreMeasurement } from "../audio/measure.ts";
+import { VOICE_PREVIEWABLE_TOOLS } from "./voice-tools.ts";
 import type {
   ActionContext,
   AgentTool,
@@ -40,6 +41,7 @@ export const PREVIEWABLE_TOOLS: readonly string[] = Object.freeze([
   "set_synth",
   "set_string",
   "set_modal",
+  "set_wind",
   "set_sample",
   "fit_sample",
   "set_effects",
@@ -47,6 +49,8 @@ export const PREVIEWABLE_TOOLS: readonly string[] = Object.freeze([
   "set_granular",
   "set_drum_kit",
   "use_sound",
+  // 0.7 Voice: flagged per lane in voice-tools.ts.
+  ...VOICE_PREVIEWABLE_TOOLS,
 ]);
 
 const MAX_CHANGES = 8;
@@ -159,7 +163,7 @@ export function previewSoundTool(
   return {
     name: "preview_sound",
     description:
-      "Hear a track, or a candidate sound change, without committing it. changes: sound tool calls to try ({tool, args} for set_fx, set_rig, set_synth, set_string, set_modal, set_wavetable, set_instrument, set_sample, fit_sample, set_effects, set_mix, set_automation, set_drum_kit, use_sound), applied to a copy. Renders the track's notes over up to 4 bars (or a short phrase by role when it has none), solo or in context, and returns RMS/peak dBFS, spectral centroid and a one-line description for the current and the candidate sound. When the user's window is open it plays the snippet once. Then commit with the normal tools if it sounds right.",
+      "Hear a track, or a candidate sound change, without committing it. changes: sound tool calls to try ({tool, args} for set_fx, set_rig, set_synth, set_string, set_modal, set_wind, set_wavetable, set_instrument, set_sample, fit_sample, set_mix, set_automation, set_drum_kit, use_sound), applied to a copy. Renders the track's notes over up to 4 bars (or a short phrase by role when it has none), solo or in context, and returns RMS/peak dBFS, spectral centroid and a one-line description for the current and the candidate sound. When the user's window is open it plays the snippet once. Then commit with the normal tools if it sounds right.",
     parameters: {
       type: "object",
       properties: {

package/src/agent/provider.ts

@@ -1,3 +1,4 @@
+import { runCommandAgentTurn } from "./command-agent.ts";
 import { statSync } from "node:fs";
 import { join } from "node:path";
 import {
@@ -29,6 +30,7 @@ import {
 } from "./gateway.ts";
 import {
   defaultModelId,
+  fallbackModelId,
   MODEL_CATALOG,
   modelAlias,
   resolveModelChoice,
@@ -90,7 +92,7 @@ export function isApiSelection(
   return selection.kind === "gateway" || selection.kind === "openrouter";
 }
 
-export const LOGIN_HINT = "run `dawg login` to enable the agent";
+export const LOGIN_HINT = "run `dawg model key` to enable the agent";
 /** The small, cheap model used for one-line helpers such as session names. */
 export const GATEWAY_SMALL_MODEL = "anthropic/claude-haiku-4.5";
 export const OPENROUTER_SMALL_MODEL = "anthropic/claude-haiku-4.5";
@@ -113,7 +115,7 @@ export function providerChoice(
 
 /**
  * The model for a key-based provider: `DAWG_MODEL`, then the model saved by
- * `/model` or `dawg login`, then Opus 5.5. Throws on an unknown `DAWG_MODEL`.
+ * `/model` or `dawg model key`, then Opus 5.5. Throws on an unknown `DAWG_MODEL`.
  */
 export function apiModelId(
   service: ApiProvider,
@@ -186,14 +188,14 @@ export async function selectProvider(
     }
     if (choice === service)
       return offline(
-        `no ${service === "gateway" ? "AI Gateway" : "OpenRouter"} key any more; run \`dawg login ${service}\``,
+        `no ${service === "gateway" ? "AI Gateway" : "OpenRouter"} key any more; run \`dawg model key ${service}\``,
       );
   }
   const bin = resolveXcbBin(auth.env, auth.runner);
   if (!bin)
     return offline(
       explicit
-        ? `xcb is not installed; run \`dawg login ${choice === "xcb" ? "--xcb" : choice}\``
+        ? `xcb is not installed; run \`dawg model key ${choice === "xcb" ? "--xcb" : choice}\``
         : `no model configured; ${LOGIN_HINT}`,
     );
   let capabilities: XcbCapabilities;
@@ -251,7 +253,7 @@ export async function selectProvider(
                     "<account>",
                     account.id,
                   )
-          }; run \`dawg login ${family === "xcb" ? "--xcb" : family}\``,
+          }; run \`dawg model key ${family === "xcb" ? "--xcb" : family}\``,
         );
     }
     // No saved pick: the first usable account, ready before admission pending.
@@ -274,7 +276,7 @@ export async function selectProvider(
   }
   return offline(
     explicit
-      ? `no ${FAMILY_NAMES[choice] ?? choice} is ready; run \`dawg login ${choice === "xcb" ? "--xcb" : choice}\``
+      ? `no ${FAMILY_NAMES[choice] ?? choice} is ready; run \`dawg model key ${choice === "xcb" ? "--xcb" : choice}\``
       : `no model configured; ${LOGIN_HINT}`,
   );
 }
@@ -349,12 +351,24 @@ export async function runProviderTurn(
     ...(options.signal ? { signal: options.signal } : {}),
     ...(options.budget ? { budget: options.budget } : {}),
   };
-  if (isApiSelection(selection))
+  if (isApiSelection(selection)) {
+    const model = options.model ?? selection.modelId;
+    const fallback = fallbackModelId(selection.kind, model);
+    if (options.host.commands && !options.model)
+      return runCommandAgentTurn({
+        ...common,
+        model,
+        ...(fallback ? { fallbackModel: fallback } : {}),
+        client: options.gatewayClient ?? apiClient(selection),
+        commands: options.host.commands,
+      });
     return runAgentTurn({
       ...common,
-      model: options.model ?? selection.modelId,
+      model,
+      ...(fallback ? { fallbackModel: fallback } : {}),
       client: options.gatewayClient ?? apiClient(selection),
     });
+  }
   if (selection.kind === "xcb") {
     const runner = options.runner ?? systemRunner;
     return runTextAgentTurn({

package/src/agent/resample-tool.ts

@@ -0,0 +1,131 @@
+/**
+ * Agent tool `resample` (0.6.1): the `resample` prompt command for the
+ * model. Renders a track, an orbit or the master over the song, a section
+ * or a bar range to a pinned WAV under the project and adds a sampler (or,
+ * with grain, a granular) track that plays it, committed as ordinary score
+ * operations.
+ */
+import { SCORE_LIMITS } from "../../core/score.ts";
+import {
+  parseResampleCommand,
+  runResample,
+  type ResampleCommand,
+} from "../commands/resample.ts";
+import { hasSamplerTracks, SampleLibrary } from "../audio/samples.ts";
+import type { AgentTool } from "./tools.ts";
+
+class ResampleToolError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ToolArgumentError";
+  }
+}
+
+/** The tool's arguments as the prompt command they stand for. */
+export function resampleToolCommand(
+  args: Record<string, unknown>,
+  focusedTrackId: string,
+): ResampleCommand {
+  const words = ["resample"];
+  const source = args.source ?? "track";
+  if (source === "track") {
+    const trackId = args.trackId ?? focusedTrackId;
+    if (typeof trackId !== "string" || trackId.length === 0)
+      throw new ResampleToolError("trackId must be a track id");
+    words.push(trackId);
+  } else if (source === "orbit") {
+    if (!Number.isInteger(args.orbit))
+      throw new ResampleToolError("orbit must be an integer");
+    words.push("orbit", String(args.orbit));
+  } else if (source === "master") words.push("master");
+  else throw new ResampleToolError("source is track, orbit or master");
+  if (args.section !== undefined) {
+    if (typeof args.section !== "string" || args.section.length === 0)
+      throw new ResampleToolError("section must be a section name");
+    words.push("section", args.section);
+  } else if (args.bars !== undefined) {
+    const bars = args.bars;
+    if (
+      !Array.isArray(bars) ||
+      bars.length !== 2 ||
+      !bars.every((bar) => Number.isInteger(bar))
+    )
+      throw new ResampleToolError("bars must be [first, last], 1-based");
+    words.push("bars", `${bars[0]}-${bars[1]}`);
+  }
+  if (args.post === true) words.push("post");
+  if (args.grain === true) words.push("grain");
+  if (args.as !== undefined) {
+    if (typeof args.as !== "string")
+      throw new ResampleToolError("as must be a track id");
+    words.push("as", args.as);
+  }
+  const command = parseResampleCommand(words.join(" "));
+  if (!command) throw new ResampleToolError(`cannot ${words.join(" ")}`);
+  return command;
+}
+
+export const RESAMPLE_TOOLS: readonly AgentTool[] = Object.freeze([
+  {
+    name: "resample",
+    description:
+      "Bounce a track (default focused), an orbit (no master) or the master over the song, a section or bars [first,last] to a pinned WAV, adding a one-shot sampler track that plays it in place; grain adds a granular track instead; post keeps the master chain.",
+    parameters: {
+      type: "object",
+      properties: {
+        source: { type: "string", enum: ["track", "orbit", "master"] },
+        trackId: { type: "string", maxLength: SCORE_LIMITS.maxIdLength },
+        orbit: { type: "integer", minimum: 1, maximum: 16 },
+        section: { type: "string" },
+        bars: {
+          type: "array",
+          items: { type: "integer", minimum: 1 },
+          minItems: 2,
+          maxItems: 2,
+        },
+        grain: { type: "boolean" },
+        post: { type: "boolean" },
+        as: { type: "string", maxLength: SCORE_LIMITS.maxIdLength },
+      },
+      additionalProperties: false,
+    },
+    plan(args, context) {
+      const command = resampleToolCommand(args, context.focusedTrackId);
+      return {
+        kind: "prepare",
+        summary: "resample",
+        run: async (action) => {
+          const root = action.workspace?.root ?? process.cwd();
+          const samples = hasSamplerTracks(context.score)
+            ? await new SampleLibrary({
+                projectRoot: root,
+                ...(action.packs ? { packs: action.packs } : {}),
+              }).load(context.score)
+            : undefined;
+          const result = await runResample({
+            projectRoot: root,
+            score: context.score,
+            command,
+            ...(samples ? { samples } : {}),
+          });
+          if (!result.ok) throw new ResampleToolError(result.message);
+          const track = result.next.tracks.find(
+            (t) => t.id === result.trackId,
+          )!;
+          const notes = result.next.notes.filter(
+            (note) => note.trackId === result.trackId,
+          );
+          return {
+            kind: "score",
+            operations: [
+              { type: "addTrack", track },
+              ...notes.map((note) => ({ type: "addNote" as const, note })),
+            ],
+            summary: result.message,
+            trackId: result.trackId,
+          };
+        },
+      };
+    },
+  },
+]);

package/src/agent/rhythm-tools.ts

@@ -75,7 +75,7 @@ export const RHYTHM_TOOLS: readonly AgentTool[] = Object.freeze([
   {
     name: "set_rhythm",
     description:
-      "Preferred for drums: one row per voice of a kit/oneshot track; its notes regenerate from the row. pulses (4) over steps (16..64) Euclidean, rotate later; division 1/32..1/1 (1/16); grid 'x.X.' explicit (X accent); repeats 0..16 after each pulse every time, pace -1..1, ramp -1..1; velocity (0.8); accent 0..1 on E(accents,pulses); gate; legato; probability+seed; swing/nudge ±0.5 step; cycles [{pulses,rotate,repeats,probability,velocity}] per pass. remove [voices] (freeze keeps notes).",
+      "Preferred for drums: one row per voice of a kit/oneshot track; its notes regenerate from the row. pulses (4) over steps (16..64) Euclidean, rotate later; division 1/32..1/1 (1/16) is one step, and the steps×division cycle repeats from beat 0 to fill the loop (E(4,16) at 1/16 = a hit every beat, four on the floor; a backbeat on counts 2 and 4 is grid '....x.......x...' or E(2,16) rotate 4; offbeat 'and's are grid '..x.' ); grid 'x.X.' explicit (X accent); repeats 0..16 after each pulse every time, pace -1..1, ramp -1..1; velocity (0.8); accent 0..1 on E(accents,pulses); gate; legato; probability+seed; swing/nudge ±0.5 step; cycles [{pulses,rotate,repeats,probability,velocity}] per pass. remove [voices] (freeze keeps notes).",
     parameters: {
       type: "object",
       properties: {

package/src/agent/section-tools.ts

@@ -380,7 +380,7 @@ export const SECTION_TOOLS: readonly AgentTool[] = Object.freeze([
   },
   {
     name: "add_transition",
-    description: `Generate a transition with the built-in voices (bars count from 1). build: noise riser, accelerating snare roll, filter sweep and uplifter (all on by default), landing on the bar after its range. The range is \`bars\` bars (default 4) just before section \`into\` (the usual build into a drop or chorus); or a section's own bars (its last \`bars\` bars when bars is given); or \`bars\` bars starting at atBar; default the song's last 4 bars. The sweep is a high-pass up to 1.2 kHz on unfiltered or high-pass pitched tracks and a low-pass opening from cutoff/10 on low-pass tracks, on an octave curve, snapping back on the downbeat. drop: a pre-drop cut (cutBeats of silence, default 1, up to two bars) and an impact hit on the section's first bar or atBar (default: the section named drop, else chorus). fill: a drum fill (${FILL_STYLES.join(", ")}) in the last beats (default 1, ${FILL_BEATS_MIN} up to two bars) leading into the section or into atBar, plus a crash on its downbeat. Without section or atBar, fills go at every section boundary. Out-of-range values are clamped and the result says so.`,
+    description: `Generate a transition with the built-in voices (bars count from 1). build: noise riser, accelerating snare roll, filter sweep and uplifter (all on by default), landing on the bar after its range. The range is \`bars\` bars (default 4) just before section \`into\` (the usual build into a drop or chorus); or a section's own bars (its last \`bars\` bars when bars is given); or \`bars\` bars starting at atBar; default the song's last 4 bars. The sweep is a high-pass rising to 1.2 kHz on pitched tracks (a low-pass opening from cutoff/10 on low-pass tracks), snapping back on the downbeat. drop: a pre-drop cut (cutBeats of silence, default 1, up to two bars) and an impact hit on the section's first bar or atBar (default: the section named drop, else chorus). fill: a drum fill (${FILL_STYLES.join(", ")}) in the last beats (default 1, ${FILL_BEATS_MIN} up to two bars) leading into the section or into atBar, plus a crash on its downbeat. Without section or atBar, fills go at every section boundary. Out-of-range values are clamped.`,
     parameters: {
       type: "object",
       properties: {