bopodev-agent-sdk 0.1.19 → 0.1.22

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
 
-> bopodev-agent-sdk@0.1.19 build /Users/danielkrusenstrahle/Documents/Projects/Monorepo/bopohq/packages/agent-sdk
+> bopodev-agent-sdk@0.1.22 build /Users/danielkrusenstrahle/Documents/Projects/Monorepo/bopodev/packages/agent-sdk
 > tsc -p tsconfig.json --emitDeclarationOnly
 

package/.turbo/turbo-typecheck.log

@@ -1,4 +1,4 @@
 
-> bopodev-agent-sdk@0.1.15 typecheck /Users/danielkrusenstrahle/Documents/Projects/Monorepo/bopohq/packages/agent-sdk
+> bopodev-agent-sdk@0.1.20 typecheck /Users/danielkrusenstrahle/Documents/Projects/Monorepo/bopodev/packages/agent-sdk
 > tsc -p tsconfig.json --noEmit
 

package/dist/contracts/src/index.d.ts

@@ -1701,6 +1701,26 @@ export declare const AgentCreateRequestSchema: z.ZodObject<{
     heartbeatCron: z.ZodString;
     monthlyBudgetUsd: z.ZodNumber;
     canHireAgents: z.ZodDefault<z.ZodBoolean>;
+    sourceIssueId: z.ZodOptional<z.ZodString>;
+    sourceIssueIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    delegationIntent: z.ZodOptional<z.ZodObject<{
+        intentType: z.ZodLiteral<"agent_hiring_request">;
+        requestedRole: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        requestedName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        requestedManagerAgentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        requestedProviderType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            claude_code: "claude_code";
+            codex: "codex";
+            cursor: "cursor";
+            opencode: "opencode";
+            gemini_cli: "gemini_cli";
+            openai_api: "openai_api";
+            anthropic_api: "anthropic_api";
+            http: "http";
+            shell: "shell";
+        }>>>;
+        requestedRuntimeModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
     requestApproval: z.ZodDefault<z.ZodBoolean>;
     runtimeConfig: z.ZodDefault<z.ZodObject<{
         runtimeCommand: z.ZodOptional<z.ZodOptional<z.ZodString>>;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "bopodev-agent-sdk",
-  "version": "0.1.19",
+  "version": "0.1.22",
   "license": "MIT",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",
   "dependencies": {
-    "bopodev-contracts": "0.1.19"
+    "bopodev-contracts": "0.1.22"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json --emitDeclarationOnly",

package/src/adapters.ts

@@ -25,7 +25,7 @@ import {
   type DirectApiProvider
 } from "./runtime-http";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 
 function summarizeWork(context: HeartbeatContext) {
   if (context.workItems.length === 0) {
@@ -660,6 +660,21 @@ export async function testAdapterEnvironment(
     level: "info",
     message: `Command is executable: ${command}`
   });
+  const providerMismatch = detectProviderCommandMismatch(providerType, command);
+  if (providerMismatch) {
+    checks.push({
+      code: "command_provider_mismatch",
+      level: "error",
+      message: `Command '${command}' does not match selected provider '${providerType}'.`,
+      detail: `The command appears to be for provider '${providerMismatch}'. Select the matching provider or change the command.`
+    });
+    return {
+      providerType,
+      status: "fail",
+      testedAt: new Date().toISOString(),
+      checks
+    };
+  }
 
   if (providerType === "http") {
     return { providerType, status: "pass", testedAt: new Date().toISOString(), checks };
@@ -687,12 +702,12 @@ export async function testAdapterEnvironment(
       message: "Environment probe succeeded."
     });
   } else {
-    const detail = `${probe.stderr}\n${probe.stdout}`.trim().slice(0, 500);
-    const normalizedDetail = detail.toLowerCase();
+    const detail = summarizeProbeFailureDetail(probe.stdout, probe.stderr);
+    const rawEvidence = `${probe.stderr}\n${probe.stdout}`.toLowerCase();
     if (
       providerType === "codex" &&
-      normalizedDetail.includes("401 unauthorized") &&
-      (normalizedDetail.includes("missing bearer") || normalizedDetail.includes("authentication"))
+      rawEvidence.includes("401 unauthorized") &&
+      (rawEvidence.includes("missing bearer") || rawEvidence.includes("authentication"))
     ) {
       checks.push({
         code: "codex_auth_required",
@@ -724,6 +739,77 @@ export async function testAdapterEnvironment(
   };
 }
 
+function detectProviderCommandMismatch(providerType: AgentProviderType, command: string) {
+  const normalized = basename(command).toLowerCase();
+  const known: Record<Exclude<AgentProviderType, "http" | "shell" | "openai_api" | "anthropic_api">, string[]> = {
+    claude_code: ["claude", "claude.exe", "claude.cmd"],
+    codex: ["codex", "codex.exe", "codex.cmd"],
+    cursor: ["cursor", "cursor.exe", "cursor.cmd"],
+    opencode: ["opencode", "opencode.exe", "opencode.cmd"],
+    gemini_cli: ["gemini", "gemini.exe", "gemini.cmd"]
+  };
+  const expected = known[providerType as keyof typeof known];
+  if (!expected) {
+    return null;
+  }
+  if (expected.includes(normalized)) {
+    return null;
+  }
+  for (const [candidateProvider, aliases] of Object.entries(known)) {
+    if (candidateProvider === providerType) {
+      continue;
+    }
+    if (aliases.includes(normalized)) {
+      return candidateProvider;
+    }
+  }
+  return null;
+}
+
+function summarizeProbeFailureDetail(stdout: string, stderr: string) {
+  const lines = [...stderr.split(/\r?\n/), ...stdout.split(/\r?\n/)].map((line) => line.trim()).filter(Boolean);
+  for (const line of lines) {
+    const parsed = parseJsonRecord(line);
+    if (!parsed) {
+      return line.replace(/\s+/g, " ").slice(0, 500);
+    }
+    const type = asString(parsed.type);
+    const subtype = asString(parsed.subtype);
+    if (
+      type === "thread.started" ||
+      type === "item.started" ||
+      type === "item.completed" ||
+      (type === "system" && subtype === "init")
+    ) {
+      continue;
+    }
+    if (type === "turn.failed") {
+      const failed = asString(parsed.error) || asString(parsed.message) || asString(parsed.result);
+      if (failed) {
+        return failed.replace(/\s+/g, " ").slice(0, 500);
+      }
+    }
+    const message = asString(parsed.message) || asString(parsed.result) || asString(parsed.error);
+    if (message) {
+      return message.replace(/\s+/g, " ").slice(0, 500);
+    }
+  }
+  return "";
+}
+
+function asString(value: unknown) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function parseJsonRecord(line: string) {
+  try {
+    const parsed = JSON.parse(line) as unknown;
+    return typeof parsed === "object" && parsed !== null ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
 export function createSkippedResult(providerLabel: string, providerKey: string, context: HeartbeatContext): AdapterExecutionResult {
   return {
     status: "skipped",

package/src/runtime.ts

@@ -1403,6 +1403,7 @@ async function ensureCodexSkillsInjected(skillsSourceDir: string, env: NodeJS.Pr
   const codexHome = resolveCodexHome(env);
   const targetRoot = join(codexHome, SKILLS_DIR_NAME);
   await mkdir(targetRoot, { recursive: true });
+  await pruneBrokenSkillSymlinks(targetRoot);
 
   const entries = await readdir(skillsSourceDir, { withFileTypes: true });
   for (const entry of entries) {
@@ -1505,6 +1506,7 @@ async function withProviderRuntimeIsolation(
 
 async function ensureSkillsInjectedAtHome(skillsSourceDir: string, targetRoot: string) {
   await mkdir(targetRoot, { recursive: true });
+  await pruneBrokenSkillSymlinks(targetRoot);
   const entries = await readdir(skillsSourceDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -1517,6 +1519,27 @@ async function ensureSkillsInjectedAtHome(skillsSourceDir: string, targetRoot: s
   }
 }
 
+async function pruneBrokenSkillSymlinks(targetRoot: string) {
+  try {
+    const entries = await readdir(targetRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      const target = join(targetRoot, entry.name);
+      const stats = await lstat(target).catch(() => null);
+      if (!stats?.isSymbolicLink()) {
+        continue;
+      }
+      const resolves = await access(target)
+        .then(() => true)
+        .catch(() => false);
+      if (!resolves) {
+        await rm(target, { recursive: true, force: true }).catch(() => undefined);
+      }
+    }
+  } catch {
+    return;
+  }
+}
+
 function resolveManagedCodexHome(env: NodeJS.ProcessEnv) {
   const managedRoot = resolveManagedCodexHomeRoot(env);
   const companyId = sanitizePathSegment(resolveControlPlaneEnvValue(env, "COMPANY_ID"));

package/.turbo/turbo-lint.log

@@ -1,4 +0,0 @@
-
-> bopodev-agent-sdk@0.1.15 lint /Users/danielkrusenstrahle/Documents/Projects/Monorepo/bopohq/packages/agent-sdk
-> tsc -p tsconfig.json --noEmit
-