making it scout

Author: hugodutka

bun.lock

@@ -0,0 +1 @@
+.blink

packages/scout-agent/.gitignore

@@ -1,11 +1,11 @@
 import { tool } from "ai";
 import * as blink from "blink";
 import { z } from "zod";
-import { GeneralPurposeCore, type Message, type Options } from "./lib";
+import { type Message, type Options, Scout } from "./lib";
 
 export const agent = new blink.Agent<blink.WithUIOptions<Options, Message>>();
 
-const core = new GeneralPurposeCore({
+const scout = new Scout({
   agent,
   github: {
     appID: process.env.GITHUB_APP_ID,
@@ -27,16 +27,16 @@ const core = new GeneralPurposeCore({
 agent.on("request", async (request) => {
   const url = new URL(request.url);
   if (url.pathname.startsWith("/slack")) {
-    return core.handleSlackWebhook(request);
+    return scout.handleSlackWebhook(request);
   }
   if (url.pathname.startsWith("/github")) {
-    return core.handleGitHubWebhook(request);
+    return scout.handleGitHubWebhook(request);
   }
   return new Response("Hey there!", { status: 200 });
 });
 
 agent.on("chat", async ({ id, messages }) => {
-  return core.streamStepResponse({
+  return scout.streamStepResponse({
     chatID: id,
     messages,
     model: "anthropic/claude-sonnet-4.5",
@@ -45,12 +45,8 @@ agent.on("chat", async ({ id, messages }) => {
       get_favorite_color: tool({
         description: "Get your favorite color",
         inputSchema: z.object({}),
-        async *execute() {
-          yield "blue";
-          await new Promise((resolve) => setTimeout(resolve, 1000));
-          yield "red";
-          await new Promise((resolve) => setTimeout(resolve, 1000));
-          yield "green";
+        execute() {
+          return "blue";
         },
       }),
     },

packages/scout-agent/agent.ts

@@ -9,8 +9,7 @@
     "ignoreUnknown": false
   },
   "formatter": {
-    "enabled": true,
-    "indentStyle": "space"
+    "enabled": false
   },
   "linter": {
     "enabled": true,

packages/scout-agent/biome.json

@@ -5,7 +5,7 @@ import type { WebSocket } from "ws";
 
 export const WORKSPACE_INFO_KEY = "__compute_workspace_id";
 
-export const newComputeClient = async (ws: WebSocket) => {
+export const newComputeClient = async (ws: WebSocket): Promise<Client> => {
   return new Promise<Client>((resolve, reject) => {
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();

packages/scout-agent/lib/compute/common.ts

@@ -20,7 +20,7 @@ const parseExecOutput = (output: unknown): string => {
 };
 
 const execProcess = async (
-  command: string,
+  command: string
 ): Promise<{ stdout: string; stderr: string; exitCode: number }> => {
   try {
     const output = await exec(command, {});
@@ -42,7 +42,9 @@ const execProcess = async (
   }
 };
 
-const dockerWorkspaceInfoSchema = z.object({
+const dockerWorkspaceInfoSchema: z.ZodObject<{
+  containerName: z.ZodString;
+}> = z.object({
   containerName: z.string(),
 });
 
@@ -86,13 +88,13 @@ export const initializeDockerWorkspace =
     const { exitCode: versionExitCode } = await execProcess("docker --version");
     if (versionExitCode !== 0) {
       throw new Error(
-        `Docker is not available. Please install it or choose a different workspace provider.`,
+        `Docker is not available. Please install it or choose a different workspace provider.`
       );
     }
 
     const imageName = `blink-workspace:${DOCKERFILE_HASH}`;
     const { exitCode: dockerImageExistsExitCode } = await execProcess(
-      `docker image inspect ${imageName}`,
+      `docker image inspect ${imageName}`
     );
     if (dockerImageExistsExitCode !== 0) {
       const buildCmd = `echo "${DOCKERFILE_BASE64}" | base64 -d | docker build -t ${imageName} -f - .`;
@@ -103,14 +105,14 @@ export const initializeDockerWorkspace =
       } = await execProcess(buildCmd);
       if (buildExitCode !== 0) {
         throw new Error(
-          `Failed to build docker image ${imageName}. Build output: ${buildStdout}\n${buildStderr}`,
+          `Failed to build docker image ${imageName}. Build output: ${buildStdout}\n${buildStderr}`
         );
       }
     }
 
     const containerName = `blink-workspace-${crypto.randomUUID()}`;
     const { exitCode: runExitCode } = await execProcess(
-      `docker run -d --publish ${COMPUTE_SERVER_PORT} --name ${containerName} ${imageName} bash -c 'echo "${BOOTSTRAP_SCRIPT_BASE64}" | base64 -d | bash'`,
+      `docker run -d --publish ${COMPUTE_SERVER_PORT} --name ${containerName} ${imageName} bash -c 'echo "${BOOTSTRAP_SCRIPT_BASE64}" | base64 -d | bash'`
     );
     if (runExitCode !== 0) {
       throw new Error(`Failed to run docker container ${containerName}`);
@@ -124,11 +126,11 @@ export const initializeDockerWorkspace =
         stdout,
         stderr,
       } = await execProcess(
-        `docker container inspect -f json ${containerName}`,
+        `docker container inspect -f json ${containerName}`
       );
       if (inspectExitCode !== 0) {
         throw new Error(
-          `Failed to run docker container ${containerName}. Inspect failed: ${stdout}\n${stderr}`,
+          `Failed to run docker container ${containerName}. Inspect failed: ${stdout}\n${stderr}`
         );
       }
       const inspectOutput = dockerInspectSchema.parse(JSON.parse(stdout));
@@ -137,7 +139,7 @@ export const initializeDockerWorkspace =
       }
       if (Date.now() - start > timeout) {
         throw new Error(
-          `Timeout waiting for docker container ${containerName} to start.`,
+          `Timeout waiting for docker container ${containerName} to start.`
         );
       }
       const {
@@ -147,7 +149,7 @@ export const initializeDockerWorkspace =
       } = await execProcess(`docker container logs ${containerName}`);
       if (logsExitCode !== 0) {
         throw new Error(
-          `Failed to get logs for docker container ${containerName}. Logs: ${logsOutput}\n${logsStderr}`,
+          `Failed to get logs for docker container ${containerName}. Logs: ${logsOutput}\n${logsStderr}`
         );
       }
       if (logsOutput.includes("Compute server running")) {
@@ -166,15 +168,15 @@ const dockerInspectSchema = z.array(
       IPAddress: z.string(),
       Ports: z.object({
         [`${COMPUTE_SERVER_PORT}/tcp`]: z.array(
-          z.object({ HostPort: z.string() }),
+          z.object({ HostPort: z.string() })
         ),
       }),
     }),
-  }),
+  })
 );
 
 export const getDockerWorkspaceClient = async (
-  workspaceInfoRaw: unknown,
+  workspaceInfoRaw: unknown
 ): Promise<Client> => {
   const {
     data: workspaceInfo,
@@ -187,33 +189,33 @@ export const getDockerWorkspaceClient = async (
 
   const { stdout: dockerInspectRawOutput, exitCode: inspectExitCode } =
     await execProcess(
-      `docker container inspect -f json ${workspaceInfo.containerName}`,
+      `docker container inspect -f json ${workspaceInfo.containerName}`
     );
   if (inspectExitCode !== 0) {
     throw new Error(
-      `Failed to inspect docker container ${workspaceInfo.containerName}. Initialize a new workspace with initialize_workspace first.`,
+      `Failed to inspect docker container ${workspaceInfo.containerName}. Initialize a new workspace with initialize_workspace first.`
     );
   }
   const dockerInspect = dockerInspectSchema.parse(
-    JSON.parse(dockerInspectRawOutput),
+    JSON.parse(dockerInspectRawOutput)
   );
   const ipAddress = dockerInspect[0]?.NetworkSettings.IPAddress;
   if (!ipAddress) {
     throw new Error(
-      `Could not find IP address for docker container ${workspaceInfo.containerName}`,
+      `Could not find IP address for docker container ${workspaceInfo.containerName}`
     );
   }
   if (!dockerInspect[0]?.State.Running) {
     throw new Error(
-      `Docker container ${workspaceInfo.containerName} is not running.`,
+      `Docker container ${workspaceInfo.containerName} is not running.`
     );
   }
   const hostPort =
     dockerInspect[0]?.NetworkSettings.Ports[`${COMPUTE_SERVER_PORT}/tcp`]?.[0]
       ?.HostPort;
   if (!hostPort) {
     throw new Error(
-      `Could not find host port for docker container ${workspaceInfo.containerName}`,
+      `Could not find host port for docker container ${workspaceInfo.containerName}`
     );
   }
   return newComputeClient(new WebSocket(`ws://localhost:${hostPort}`));

packages/scout-agent/lib/compute/docker.ts

@@ -1,7 +1,7 @@
 import * as compute from "@blink-sdk/compute";
 import type { Client } from "@blink-sdk/compute-protocol/client";
 import * as github from "@blink-sdk/github";
-import { tool } from "ai";
+import { type Tool, tool } from "ai";
 import * as blink from "blink";
 import { z } from "zod";
 import { getGithubAppContext } from "../github";
@@ -10,25 +10,23 @@ import { WORKSPACE_INFO_KEY } from "./common";
 
 export const createComputeTools = ({
   agent,
-  messages,
   githubConfig,
   initializeWorkspace,
   createWorkspaceClient,
 }: {
   agent: blink.Agent<Message>;
-  messages: Message[];
   initializeWorkspace: () => Promise<unknown>;
   createWorkspaceClient: (workspaceInfo: unknown) => Promise<Client>;
   githubConfig?: {
     appID: string;
     privateKey: string;
   };
-}) => {
+}): Record<string, Tool> => {
   const newClient = async () => {
     const workspaceInfo = await agent.store.get(WORKSPACE_INFO_KEY);
     if (!workspaceInfo) {
       throw new Error(
-        "Workspace not initialized. Call initialize_workspace first.",
+        "Workspace not initialized. Call initialize_workspace first."
       );
     }
     const parsedWorkspaceInfo = JSON.parse(workspaceInfo);
@@ -43,7 +41,7 @@ export const createComputeTools = ({
         const workspaceInfo = await initializeWorkspace();
         await agent.store.set(
           WORKSPACE_INFO_KEY,
-          JSON.stringify(workspaceInfo),
+          JSON.stringify(workspaceInfo)
         );
         return "Workspace initialized.";
       },
@@ -71,11 +69,10 @@ It's safe to call this multiple times - re-authenticating is perfectly fine and
               const githubAppContext = await getGithubAppContext({
                 githubAppID: githubConfig.appID,
                 githubAppPrivateKey: githubConfig.privateKey,
-                messages,
               });
               if (!githubAppContext) {
                 throw new Error(
-                  "You can only use public repositories in this context.",
+                  "You can only use public repositories in this context."
                 );
               }
               const token = await github.authenticateApp({
@@ -98,7 +95,7 @@ It's safe to call this multiple times - re-authenticating is perfectly fine and
               });
               if (respWait.exit_code !== 0) {
                 throw new Error(
-                  `Failed to authenticate with Git. Output: ${respWait.plain_output.lines.join("\n")}`,
+                  `Failed to authenticate with Git. Output: ${respWait.plain_output.lines.join("\n")}`
                 );
               }
               return "Git authenticated.";

packages/scout-agent/lib/compute/tools.ts

@@ -7,7 +7,7 @@ import {
 import { MockLanguageModelV2 } from "ai/test";
 import * as blink from "blink";
 import { Client } from "blink/client";
-import { GeneralPurposeCore, type Message, type Options } from "./index";
+import { type Message, type Options, Scout } from "./index";
 
 // Add async iterator support to ReadableStream for testing
 declare global {
@@ -50,10 +50,10 @@ const newMockModel = ({
 
 const newAgent = (options: {
   model: MockLanguageModelV2;
-  core?: Omit<ConstructorParameters<typeof GeneralPurposeCore>[0], "agent">;
+  core?: Omit<ConstructorParameters<typeof Scout>[0], "agent">;
 }) => {
   const agent = new blink.Agent<blink.WithUIOptions<Options, Message>>();
-  const core = new GeneralPurposeCore({ agent, ...options.core });
+  const core = new Scout({ agent, ...options.core });
   agent.on("request", async () => {
     return new Response("Hello, world!", { status: 200 });
   });
@@ -166,7 +166,7 @@ const newPromise = <T>(timeoutMs: number = 5000) => {
 
 test("core class name", () => {
   // biome-ignore lint/complexity/useLiteralKeys: accessing a private field
-  expect(GeneralPurposeCore["CLASS_NAME"]).toBe(GeneralPurposeCore.name);
+  expect(Scout["CLASS_NAME"]).toBe(Scout.name);
 });
 
 describe("config", async () => {
@@ -196,7 +196,7 @@ describe("config", async () => {
             "Did you provide all required environment variables?"
           );
           expect(log).toInclude(
-            `Alternatively, you can suppress this message by setting \`suppressConfigWarnings\` to \`true\` on \`${GeneralPurposeCore.name}\`.`
+            `Alternatively, you can suppress this message by setting \`suppressConfigWarnings\` to \`true\` on \`${Scout.name}\`.`
           );
         },
       },