@loomweaver/cli 0.14.3 → 0.14.4

package/dist/main.mjs

@@ -638,9 +638,9 @@ function renderRegions(indent) {
 // ../devkit/src/recipes/angular-weaver/agent-panel.ts
 function panelFile(weaver) {
   return `import { ChangeDetectionStrategy, Component, signal } from '@angular/core';
-import { EventType, type BaseEvent, type Tool, type ToolMessage } from '@ag-ui/core';
-import { ${weaver.propertyName}Agent } from './${weaver.id}-agent';
-import { askAgent } from './${weaver.id}-agent-source';
+import { EventType, type AGUIEvent, type Tool, type ToolMessage } from '@ag-ui/core';
+import { askAgent } from './${weaver.id}-agent';
+import { ${weaver.propertyName}Tools } from './${weaver.id}-connection';
 
 interface Line {
   readonly kind: 'you' | 'agent' | 'call' | 'result' | 'note';
@@ -670,11 +670,11 @@ export class ${weaver.className}AgentPanel {
   // The list is read again whenever the panel gains focus, because the weaver's own translations
   // and other plugins' commands may arrive after this component was built.
   protected refreshOffered(): void {
-    this.offered.set(${weaver.propertyName}Agent()?.list() ?? []);
+    this.offered.set(${weaver.propertyName}Tools()?.list() ?? []);
   }
 
   protected async ask(name: string): Promise<void> {
-    const tools = ${weaver.propertyName}Agent();
+    const tools = ${weaver.propertyName}Tools();
     if (!tools || this.busy()) {
       return;
     }
@@ -717,24 +717,19 @@ export class ${weaver.className}AgentPanel {
     }
   }
 
-  private draw(event: BaseEvent): void {
-    const raw = event as unknown as Record<string, unknown>;
+  private draw(event: AGUIEvent): void {
     switch (event.type) {
       case EventType.TEXT_MESSAGE_START:
         this.push({ kind: 'agent', text: '' });
         break;
       case EventType.TEXT_MESSAGE_CONTENT:
-        this.grow('text', String(raw['delta'] ?? ''));
+        this.grow('text', event.delta);
         break;
       case EventType.TOOL_CALL_START:
-        this.push({
-          kind: 'call',
-          text: String(raw['toolCallName'] ?? ''),
-          args: '',
-        });
+        this.push({ kind: 'call', text: event.toolCallName, args: '' });
         break;
       case EventType.TOOL_CALL_ARGS:
-        this.grow('args', String(raw['delta'] ?? ''));
+        this.grow('args', event.delta);
         break;
       default:
         break;
@@ -763,7 +758,7 @@ function panelTemplateFile(weaver) {
     class="shrink-0 rounded-md border border-border bg-surface-raised px-3 py-2 text-xs text-content-muted"
   >
     This is a stand-in, not an assistant. It speaks the protocol so you can watch the whole path;
-    replace <code class="text-content">${weaver.id}-agent-source.ts</code> with your own transport.
+    replace <code class="text-content">${weaver.id}-agent.ts</code> with your own transport.
   </p>
 
   <div class="min-h-0 flex-1 overflow-auto">
@@ -831,7 +826,7 @@ function panelTemplateFile(weaver) {
 
 // ../devkit/src/recipes/angular-weaver/agent-stand-in.ts
 function standInFile(weaver) {
-  return `import { EventType, type BaseEvent, type Tool } from '@ag-ui/core';
+  return `import { EventType, type AGUIEvent, type Tool } from '@ag-ui/core';
 
 // WHAT THIS IS: a stand-in for an agent, and not an agent. It speaks the AG-UI protocol and nothing
 // else \u2014 no model, no network, no judgement \u2014 so that the whole path from the offered tools through
@@ -851,15 +846,16 @@ export interface AgentRequest {
 
 export async function* askAgent(
   request: AgentRequest,
-): AsyncGenerator<BaseEvent> {
+): AsyncGenerator<AGUIEvent> {
   const picked = request.tools.find((tool) =>
     request.prompt.includes(tool.name),
   );
 
-  yield event(EventType.RUN_STARTED, {
+  yield {
+    type: EventType.RUN_STARTED,
     threadId: '${weaver.id}-stand-in',
     runId: request.runId,
-  });
+  };
   yield* speak(
     \`\${request.runId}.says\`,
     picked
@@ -869,37 +865,35 @@ export async function* askAgent(
 
   if (picked) {
     const toolCallId = \`\${request.runId}.call\`;
-    yield event(EventType.TOOL_CALL_START, {
-      toolCallId,
-      toolCallName: picked.name,
-    });
+    yield { type: EventType.TOOL_CALL_START, toolCallId, toolCallName: picked.name };
     // Arguments arrive in pieces, exactly as they do from a real model. The adapter assembles them;
     // nothing downstream ever sees a half-written call. The values come from the JSON Schema the
     // workbench described in picked.parameters: the first declared choice of the first argument that
     // has choices, and nothing for the rest, so the command applies its own defaults there.
     for (const piece of chunks(JSON.stringify(sampleArguments(picked)), 4)) {
-      yield event(EventType.TOOL_CALL_ARGS, { toolCallId, delta: piece });
+      yield { type: EventType.TOOL_CALL_ARGS, toolCallId, delta: piece };
       await pause();
     }
-    yield event(EventType.TOOL_CALL_END, { toolCallId });
+    yield { type: EventType.TOOL_CALL_END, toolCallId };
   }
 
-  yield event(EventType.RUN_FINISHED, {
+  yield {
+    type: EventType.RUN_FINISHED,
     threadId: '${weaver.id}-stand-in',
     runId: request.runId,
-  });
+  };
 }
 
 async function* speak(
   messageId: string,
   text: string,
-): AsyncGenerator<BaseEvent> {
-  yield event(EventType.TEXT_MESSAGE_START, { messageId, role: 'assistant' });
+): AsyncGenerator<AGUIEvent> {
+  yield { type: EventType.TEXT_MESSAGE_START, messageId, role: 'assistant' };
   for (const piece of chunks(text, 10)) {
-    yield event(EventType.TEXT_MESSAGE_CONTENT, { messageId, delta: piece });
+    yield { type: EventType.TEXT_MESSAGE_CONTENT, messageId, delta: piece };
     await pause();
   }
-  yield event(EventType.TEXT_MESSAGE_END, { messageId });
+  yield { type: EventType.TEXT_MESSAGE_END, messageId };
 }
 
 function sampleArguments(tool: Tool): Record<string, unknown> {
@@ -922,10 +916,6 @@ function chunks(text: string, size: number): readonly string[] {
   return pieces;
 }
 
-function event(type: EventType, fields: Record<string, unknown>): BaseEvent {
-  return { type, ...fields } as unknown as BaseEvent;
-}
-
 function pause(): Promise<void> {
   return new Promise((done) => setTimeout(done, PAUSE_MS));
 }
@@ -944,15 +934,18 @@ import {
 } from '@loomweaver/ag-ui';
 import type { PluginContext } from '@loomweaver/plugin-sdk';
 
+// The connection is the workbench's half: the commands offered as tools, and each call put to the
+// workbench and answered. The agent is yours and lives beside it, in ${weaver.id}-agent.ts.
+//
 // A factory, not a module-level connection: everything a run needs lives in the closure, so a second
 // one never shares state with the first.
-export function ${weaver.propertyName}Connection(ctx: PluginContext): CommandTools {
+export function connect${weaver.className}(ctx: PluginContext): CommandTools {
   return commandTools(ctx, { before: (call) => decide(ctx, call) });
 }
 
 // The one connection this plugin activates, published for its panel. Set in activate(), cleared in
 // deactivate(), so the panel renders an honest empty state either side of that.
-export const ${weaver.propertyName}Agent = signal<CommandTools | null>(null);
+export const ${weaver.propertyName}Tools = signal<CommandTools | null>(null);
 
 // What an agent's word is enough for is the command's own statement, declared where the command is
 // registered and read off the call here. No list of ids lives beside the commands: a list drifts from
@@ -987,9 +980,10 @@ async function decide(
 `;
 }
 function specFile(weaver) {
-  return `import { EventType, type BaseEvent } from '@ag-ui/core';
+  return `import { EventType, type AGUIEvent, type ToolMessage } from '@ag-ui/core';
+import type { CommandTools } from '@loomweaver/ag-ui';
 import type { CommandArguments, PluginContext } from '@loomweaver/plugin-sdk';
-import { ${weaver.propertyName}Connection } from './${weaver.id}-agent';
+import { connect${weaver.className} } from './${weaver.id}-connection';
 
 interface Asked {
   readonly id: string;
@@ -1010,37 +1004,36 @@ function contextThat(confirms: boolean, ran: Asked[]): PluginContext {
   } as unknown as PluginContext;
 }
 
-function event(type: EventType, fields: Record<string, unknown>): BaseEvent {
-  return { type, ...fields } as unknown as BaseEvent;
+function streamedCall(toolCallId: string, ...deltas: string[]): AGUIEvent[] {
+  return [
+    { type: EventType.TOOL_CALL_START, toolCallId, toolCallName: '${weaver.id}.hello' },
+    ...deltas.map((delta): AGUIEvent => ({ type: EventType.TOOL_CALL_ARGS, toolCallId, delta })),
+    { type: EventType.TOOL_CALL_END, toolCallId },
+  ];
 }
 
-describe('${weaver.propertyName}Connection', () => {
+async function answersTo(tools: CommandTools, events: AGUIEvent[]): Promise<ToolMessage[]> {
+  const answers: ToolMessage[] = [];
+  for (const event of events) {
+    const answer = await tools.receive(event);
+    if (answer) {
+      answers.push(answer);
+    }
+  }
+  return answers;
+}
+
+describe('connect${weaver.className}', () => {
   it('offers what the workbench offers', () => {
-    const tools = ${weaver.propertyName}Connection(contextThat(true, []));
+    const tools = connect${weaver.className}(contextThat(true, []));
     expect(tools.list().map((tool) => tool.name)).toEqual(['${weaver.id}.hello']);
   });
 
   it('assembles a call from its events and answers with the outcome', async () => {
     const ran: Asked[] = [];
-    const tools = ${weaver.propertyName}Connection(contextThat(true, ran));
+    const tools = connect${weaver.className}(contextThat(true, ran));
 
-    expect(
-      await tools.receive(
-        event(EventType.TOOL_CALL_START, {
-          toolCallId: 'c1',
-          toolCallName: '${weaver.id}.hello',
-        }),
-      ),
-    ).toBeNull();
-    await tools.receive(
-      event(EventType.TOOL_CALL_ARGS, { toolCallId: 'c1', delta: '{"tone"' }),
-    );
-    await tools.receive(
-      event(EventType.TOOL_CALL_ARGS, { toolCallId: 'c1', delta: ':"success"}' }),
-    );
-    const answer = await tools.receive(
-      event(EventType.TOOL_CALL_END, { toolCallId: 'c1' }),
-    );
+    const [answer] = await answersTo(tools, streamedCall('c1', '{"tone"', ':"success"}'));
 
     expect(ran).toEqual([{ id: '${weaver.id}.hello', args: { tone: 'success' } }]);
     expect(JSON.parse(answer?.content ?? '{}').tone).toBe('success');
@@ -1049,20 +1042,9 @@ describe('${weaver.propertyName}Connection', () => {
 
   it('never reaches the workbench when a consequential call is declined', async () => {
     const ran: Asked[] = [];
-    const tools = ${weaver.propertyName}Connection(contextThat(false, ran));
+    const tools = connect${weaver.className}(contextThat(false, ran));
 
-    await tools.receive(
-      event(EventType.TOOL_CALL_START, {
-        toolCallId: 'c2',
-        toolCallName: '${weaver.id}.hello',
-      }),
-    );
-    await tools.receive(
-      event(EventType.TOOL_CALL_ARGS, { toolCallId: 'c2', delta: '{}' }),
-    );
-    const answer = await tools.receive(
-      event(EventType.TOOL_CALL_END, { toolCallId: 'c2' }),
-    );
+    const [answer] = await answersTo(tools, streamedCall('c2', '{}'));
 
     expect(ran).toEqual([]);
     expect(answer?.error).toContain('did not run');
@@ -1084,13 +1066,13 @@ function agentSurfaceBlock(weaver) {
 }
 function agentFiles(weaver) {
   const files = {
-    [`src/lib/agent/${weaver.id}-agent.ts`]: connectionFile(weaver),
-    [`src/lib/agent/${weaver.id}-agent-source.ts`]: standInFile(weaver),
+    [`src/lib/agent/${weaver.id}-connection.ts`]: connectionFile(weaver),
+    [`src/lib/agent/${weaver.id}-agent.ts`]: standInFile(weaver),
     [`src/lib/agent/${weaver.id}-agent-panel.ts`]: panelFile(weaver),
     [`src/lib/agent/${weaver.id}-agent-panel.html`]: panelTemplateFile(weaver)
   };
   if (weaver.features.spec) {
-    files[`src/lib/agent/${weaver.id}-agent.spec.ts`] = specFile(weaver);
+    files[`src/lib/agent/${weaver.id}-connection.spec.ts`] = specFile(weaver);
   }
   return files;
 }
@@ -1551,7 +1533,7 @@ function pluginImports(weaver) {
   }
   if (weaver.features.agent) {
     imports.push(
-      `import { ${weaver.propertyName}Agent, ${weaver.propertyName}Connection } from '../agent/${weaver.id}-agent';`,
+      `import { connect${weaver.className}, ${weaver.propertyName}Tools } from '../agent/${weaver.id}-connection';`,
       `import { ${weaver.className}AgentPanel } from '../agent/${weaver.id}-agent-panel';`
     );
   }
@@ -1576,7 +1558,7 @@ function pluginBody(weaver) {
   const body = [`    ctx.contributeIcons({ '${weaver.id}': icon });`];
   if (weaver.features.agent) {
     body.push(
-      `    ${weaver.propertyName}Agent.set(${weaver.propertyName}Connection(ctx));`
+      `    ${weaver.propertyName}Tools.set(connect${weaver.className}(ctx));`
     );
   }
   if (weaver.features.command) body.push(commandBlock(weaver));
@@ -1593,7 +1575,7 @@ function pluginFile(weaver) {
   const body = pluginBody(weaver);
   const deactivate = weaver.features.agent ? `
   deactivate() {
-    ${weaver.propertyName}Agent.set(null);
+    ${weaver.propertyName}Tools.set(null);
   },` : "";
   return `${pluginImports(weaver).join("\n")}
 
@@ -1616,7 +1598,7 @@ function accessLine(weaver) {
 }
 
 // ../devkit/src/recipes/platform-version.ts
-var PLATFORM_VERSION = "0.14.3";
+var PLATFORM_VERSION = "0.14.4";
 
 // ../devkit/src/recipes/readme-notes.ts
 var UNTAGGED_NOTE = [
@@ -1690,11 +1672,11 @@ function agentNotes(weaver) {
     "",
     `\`src/lib/agent/\` holds three files and one of them is meant to be thrown away.`,
     "",
-    `- \`${weaver.id}-agent.ts\` is the connection: the workbench's own commands offered as tools, and a`,
+    `- \`${weaver.id}-connection.ts\` is the connection: the workbench's own commands offered as tools, and a`,
     "  seam where this weaver decides about a call before it runs. Nothing is registered twice \u2014 the",
     "  list comes from the workbench, already narrowed by everything that would refuse the call.",
     `- \`${weaver.id}-agent-panel.ts\` shows what is offered, the call as it streams, and the outcome.`,
-    `- \`${weaver.id}-agent-source.ts\` is a **stand-in**, not an assistant: it produces the protocol's own`,
+    `- \`${weaver.id}-agent.ts\` is a **stand-in** for the agent, not an assistant: it produces the protocol's own`,
     "  events so the whole path runs before you have connected anything. Replace that one file with",
     "  your transport and nothing else changes. No transport, credential or model is generated for",
     "  you, because none of them can be guessed.",
@@ -5217,7 +5199,7 @@ function validateCatalogCommand(args, io) {
 }
 
 // src/lib/run.ts
-var VERSION = "0.14.3";
+var VERSION = "0.14.4";
 var COMMANDS = /* @__PURE__ */ new Map([
   ["init", init],
   ["list", list],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomweaver/cli",
-  "version": "0.14.3",
+  "version": "0.14.4",
   "description": "LoomWeaver: open-source plugin platform for Angular workbenches. The scaffolding CLI: generates weavers, distributions and integrations into any project, with no Nx workspace and no checkout required.",
   "keywords": [
     "loomweaver",