agent-devkit 0.3.4 → 0.3.5

package/README.md

@@ -3,7 +3,7 @@
 Agent DevKit is a TypeScript/Node rewrite of the `agent-devkit` package.
 
 The public npm package is `agent-devkit`; the canonical command is `agent`.
-Version `0.3.4` starts a new implementation focused on a maintainable CLI/TUI
+Version `0.3.5` starts a new implementation focused on a maintainable CLI/TUI
 runtime while preserving the product direction from the legacy `0.3.x` line.
 
 ## Status
@@ -145,7 +145,7 @@ Rules:
 ## Distribution
 
 The package is npm-first and publishes the `agent` binary from `dist/main.js`.
-Standalone binaries are outside the initial `0.3.4` scope.
+Standalone binaries are outside the initial `0.3.5` scope.
 
 Installing the npm package must not create runtime folders or project files.
 State is created only when the user runs the tool:
@@ -187,8 +187,8 @@ agent reset --dry-run
 agent reset --yes
 agent reset -g --dry-run
 agent update --latest --dry-run
-agent update 0.3.4 --dry-run
-agent update 0.3.4 --yes
+agent update 0.3.5 --dry-run
+agent update 0.3.5 --yes
 agent preferences
 agent preferences --json
 agent preferences themes

package/dist/main.js

@@ -8,7 +8,7 @@ import React from "react";
 // package.json
 var package_default = {
   name: "agent-devkit",
-  version: "0.3.4",
+  version: "0.3.5",
   description: "Agent DevKit CLI and TUI runtime for specialist AI agents, capabilities and provider-aware workflows.",
   license: "MIT",
   type: "module",
@@ -50,7 +50,7 @@ var package_default = {
     "release:verify": "node scripts/verify-release-alignment.mjs",
     test: "npm run test:architecture && npm run test:infra && npm run test:app && npm run test:modules",
     "test:app": "vitest run src/app/cli/commands src/app/mcp src/app/tui src/package.test.ts",
-    "test:architecture": "vitest run src/architecture.test.ts src/modules/capability_registry.test.ts src/modules/capability_tool_runtime.test.ts src/modules/modules.registry.test.ts",
+    "test:architecture": "vitest run src/agent src/architecture.test.ts src/modules/capability_registry.test.ts src/modules/capability_tool_runtime.test.ts src/modules/modules.registry.test.ts",
     "test:infra": "vitest run src/infra",
     "test:module": "tsx scripts/test-modules.ts",
     "test:modules": "tsx scripts/test-modules.ts",
@@ -8153,7 +8153,7 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
-// src/infra/agent/agent_runtime.ts
+// src/agent/agent.brain.ts
 import { z as z23 } from "zod";
 var AgentDecisionSchema = z23.discriminatedUnion("action", [
   z23.object({ action: z23.literal("tool"), input: z23.unknown(), tool: z23.string().min(1) }),
@@ -8169,10 +8169,68 @@ var agentDecisionJsonSchema = {
   },
   required: ["action"]
 };
+function maxToolCallsFor(tools) {
+  return Math.max(1, tools.length);
+}
+function buildToolDecisionPrompt(input) {
+  const toolList = input.tools.map((tool) => `- ${tool.id} (${tool.risk}): ${tool.description}`).join("\n");
+  const instruction = [
+    `Tarefa do usu\xE1rio: ${input.task}`,
+    "",
+    "Ferramentas dispon\xEDveis:",
+    toolList,
+    "",
+    'Responda SOMENTE com JSON. Para usar uma ferramenta: {"action":"tool","tool":"<id>","input":{...}}. Para responder ao usu\xE1rio: {"action":"final","reply":"<texto>"}. Uma a\xE7\xE3o por vez.'
+  ].join("\n");
+  return AgentPromptSchema.parse({
+    agent: {
+      behavior: "balanced",
+      characterId: "agent",
+      detailLevel: "concise",
+      name: "Agent",
+      tone: "direct",
+      traits: []
+    },
+    context: {
+      knowledge: [
+        {
+          content: "You are the Agent DevKit orchestration runtime. Choose tools only when they directly help complete the user's task.",
+          id: "agent.runtime.identity"
+        }
+      ]
+    },
+    locale: "pt-BR",
+    messages: input.transcript,
+    output: { format: "json", language: "pt-BR" },
+    policies: {
+      allowToolCalls: true,
+      approvalRequired: false,
+      maxToolCalls: maxToolCallsFor(input.tools)
+    },
+    schema: "agent-devkit.prompt/v1",
+    task: { userMessage: instruction },
+    tools: input.tools.map((tool) => ({
+      description: tool.description,
+      id: tool.id,
+      inputSchema: tool.inputSchema,
+      risk: tool.risk
+    }))
+  });
+}
+
+// src/agent/agent.policy.ts
+function isToolApproved(tool, input) {
+  if (input.approvedTools !== void 0) {
+    return input.approvedTools.includes(tool);
+  }
+  return input.approved === true;
+}
+
+// src/agent/agent.loop.ts
 function summarize(value) {
   const text2 = typeof value === "string" ? value : JSON.stringify(value ?? "");
   const compact2 = text2.replaceAll(/\s+/g, " ").trim();
-  return compact2.length > 240 ? `${compact2.slice(0, 240)}\u2026` : compact2;
+  return compact2.length > 240 ? `${compact2.slice(0, 240)}...` : compact2;
 }
 function observationSummary(result) {
   if (result.status === "succeeded") {
@@ -8180,7 +8238,7 @@ function observationSummary(result) {
   }
   return `${result.status}${result.error === void 0 ? "" : `: ${result.error.message}`}`;
 }
-var AgentRuntime = class {
+var AgentToolLoop = class {
   #brain;
   #tools;
   constructor(options) {
@@ -8200,7 +8258,11 @@ var AgentRuntime = class {
     }));
     const tools = this.#tools.listTools();
     for (let step = 0; step < maxSteps; step += 1) {
-      const prompt = this.#buildPrompt(input.task, transcript, tools);
+      const prompt = buildToolDecisionPrompt({
+        task: input.task,
+        tools,
+        transcript
+      });
       const request = {
         options: { provider: "local", role: "agent" },
         prompt,
@@ -8212,19 +8274,19 @@ var AgentRuntime = class {
       }
       const decision = AgentDecisionSchema.safeParse(structured.unwrap().json);
       if (!decision.success) {
-        return Result.ok({ reply: structured.unwrap().raw.trim(), steps });
+        return Result.ok({ mode: "task", reply: structured.unwrap().raw.trim(), steps });
       }
       if (decision.data.action === "final") {
         input.onEvent?.({ reply: decision.data.reply, type: "final" });
-        return Result.ok({ reply: decision.data.reply, steps });
+        return Result.ok({ mode: "task", reply: decision.data.reply, steps });
       }
       const tool = decision.data.tool;
       input.onEvent?.({ tool, type: "tool" });
       const execution = await this.#tools.execute({
-        approved: this.#isApproved(tool, input),
+        approved: isToolApproved(tool, input),
         capabilityId: tool,
         input: decision.data.input,
-        interface: "agent",
+        interface: input.interface ?? "agent",
         requestedBy: "agent.run"
       });
       const ok = execution.status === "succeeded";
@@ -8234,64 +8296,86 @@ var AgentRuntime = class {
       transcript.push({ content: `Observation from ${tool}: ${summary}`, role: "tool" });
       if (execution.status === "approval_required") {
         return Result.ok({
+          mode: "task",
           reply: `A ferramenta ${tool} requer aprova\xE7\xE3o expl\xEDcita. Reexecute autorizando para continuar.`,
           steps
         });
       }
     }
     return Result.ok({
+      mode: "task",
       reply: "Limite de passos do agente atingido sem uma resposta final.",
       steps
     });
   }
-  #isApproved(tool, input) {
-    if (input.approvedTools !== void 0) {
-      return input.approvedTools.includes(tool);
+};
+
+// src/agent/agent.runtime.ts
+function textInput(input) {
+  return (input.message ?? input.task ?? "").trim();
+}
+function resolveMode(input) {
+  if (input.mode === "chat" || input.mode === "task") {
+    return input.mode;
+  }
+  if (input.message !== void 0) {
+    return "chat";
+  }
+  return "task";
+}
+function chatInput(input, message) {
+  return {
+    characterId: input.characterId,
+    includeHistory: input.includeHistory,
+    interface: input.interface ?? "cli",
+    message,
+    projectId: input.projectId,
+    sessionId: input.sessionId
+  };
+}
+var AgentRuntime = class {
+  #conversation;
+  #toolLoop;
+  constructor(options) {
+    this.#conversation = options.conversation;
+    this.#toolLoop = new AgentToolLoop({
+      brainProvider: options.brainProvider,
+      toolRuntime: options.toolRuntime
+    });
+  }
+  async run(input) {
+    const message = textInput(input);
+    if (message.length === 0) {
+      return Result.fail(ErrorCodes.InvalidInput);
+    }
+    const mode = resolveMode(input);
+    if (mode === "chat") {
+      return this.#runChat(input, message);
     }
-    return input.approved === true;
+    return this.#toolLoop.run({ ...input, task: message });
   }
-  #buildPrompt(task, transcript, tools) {
-    const toolList = tools.map((tool) => `- ${tool.id} (${tool.risk}): ${tool.description}`).join("\n");
-    const instruction = [
-      `Tarefa do usu\xE1rio: ${task}`,
-      "",
-      "Ferramentas dispon\xEDveis:",
-      toolList,
-      "",
-      'Responda SOMENTE com JSON. Para usar uma ferramenta: {"action":"tool","tool":"<id>","input":{...}}. Para responder ao usu\xE1rio: {"action":"final","reply":"<texto>"}. Uma a\xE7\xE3o por vez.'
-    ].join("\n");
-    return AgentPromptSchema.parse({
-      agent: {
-        behavior: "balanced",
-        characterId: "agent",
-        detailLevel: "concise",
-        name: "Agent",
-        tone: "direct",
-        traits: []
-      },
-      context: { knowledge: [] },
-      locale: "pt-BR",
-      messages: transcript,
-      output: { format: "json", language: "pt-BR" },
-      policies: {
-        allowToolCalls: true,
-        approvalRequired: false,
-        maxToolCalls: maxToolCallsFor(tools)
-      },
-      schema: "agent-devkit.prompt/v1",
-      task: { userMessage: instruction },
-      tools: tools.map((tool) => ({
-        description: tool.description,
-        id: tool.id,
-        inputSchema: tool.inputSchema,
-        risk: tool.risk
-      }))
+  async #runChat(input, message) {
+    if (this.#conversation === void 0) {
+      return Result.fail(ErrorCodes.BrainProviderUnavailable);
+    }
+    const result = await this.#conversation.chat(chatInput(input, message), {
+      approved: input.approved,
+      interface: input.interface ?? "cli",
+      requestedBy: "agent.chat"
+    });
+    if (result.isErr()) {
+      return Result.fail(result.unwrapError());
+    }
+    const conversation = result.unwrap();
+    input.onEvent?.({ reply: conversation.reply, type: "final" });
+    return Result.ok({
+      conversation,
+      mode: "chat",
+      reply: conversation.reply,
+      steps: []
     });
   }
 };
-function maxToolCallsFor(tools) {
-  return Math.max(1, tools.length);
-}
 
 // src/app/mcp/mcp_result_mapper.ts
 function inputSchemaWithAgentControl(tool) {
@@ -8446,7 +8530,7 @@ function createAgentMcpServer(options) {
       if (task.length === 0) {
         return { content: [{ type: "text", text: "Missing 'task'." }], isError: true };
       }
-      const run = await agent.run({ approvedTools, task });
+      const run = await agent.run({ approvedTools, interface: "mcp", mode: "task", task });
       if (run.isErr()) {
         return {
           content: [{ type: "text", text: `Agent run failed: ${run.unwrapError()}` }],
@@ -10142,7 +10226,31 @@ async function saveActiveCliSessionId(dataStore, sessionId) {
     { atomic: true }
   );
 }
-async function runRootConversation(message) {
+function createConversationPort(chat) {
+  return {
+    chat: async (input, context) => {
+      const result = await chat.invoke(
+        {
+          action: "send",
+          characterId: input.characterId,
+          includeHistory: input.includeHistory,
+          message: input.message,
+          projectId: input.projectId,
+          sessionId: input.sessionId
+        },
+        context
+      );
+      return result.map((payload) => ({
+        brain: payload.brain,
+        projectId: payload.projectId,
+        raw: payload,
+        reply: payload.reply,
+        sessionId: payload.sessionId
+      }));
+    }
+  };
+}
+async function runRootConversation(message, options) {
   const homeDirectory = homedir22();
   const dataStore = new LocalAgentDataStore({
     rootDirectory: `${homeDirectory}/.agent-devkit/data`
@@ -10163,17 +10271,34 @@ async function runRootConversation(message) {
     dataStore,
     contextBindings.unwrap().capabilities.sessions
   );
-  const result = await bindings.unwrap().capabilities.chat.execute({
-    action: "send",
+  const agent = new AgentRuntime({
+    brainProvider: createBrainDockProvider({ stateDirectory: `${homeDirectory}/.agent-devkit` }),
+    conversation: createConversationPort(bindings.unwrap().capabilities.chat),
+    toolRuntime: createCliToolRuntime({
+      currentVersion: options.currentVersion,
+      packageName: options.packageName
+    })
+  });
+  const result = await agent.run({
+    interface: "cli",
     message,
+    mode: "chat",
     sessionId: activeSessionId
   });
   if (result.isErr()) {
     throw new Error(result.unwrapError());
   }
   const payload = result.unwrap();
-  await saveActiveCliSessionId(dataStore, payload.sessionId);
-  console.log(formatConversationChatText(payload));
+  const rawConversation = payload.conversation?.raw;
+  if (payload.conversation === void 0 || !isConversationChatResult(rawConversation)) {
+    throw new Error("Agent did not return a conversation result.");
+  }
+  await saveActiveCliSessionId(dataStore, payload.conversation.sessionId);
+  console.log(formatConversationChatText(rawConversation));
+}
+function isConversationChatResult(value) {
+  const candidate = value;
+  return typeof value === "object" && value !== null && candidate.action === "send" && typeof candidate.reply === "string" && typeof candidate.sessionId === "string";
 }
 
 // src/infra/helpers/redaction.ts
@@ -10514,7 +10639,10 @@ program.name("agent").description(translator.t("cli.root.description")).version(
       program.error(translator.t("cli.root.removedChatCommand"));
     }
     if (initialPrompt.length > 0) {
-      await runRootConversation(initialPrompt);
+      await runRootConversation(initialPrompt, {
+        currentVersion: package_default.version,
+        packageName: package_default.name
+      });
       return;
     }
     await ensureFirstRunModel(translator);