@dobby.ai/dobby 0.1.0 → 0.1.1

package/plugins/provider-pi/src/contribution.ts

@@ -42,10 +42,32 @@ type RuntimeTool = NonNullable<CreateAgentSessionOptions["tools"]>[number];
 interface PiProviderConfig {
   provider: string;
   model: string;
+  baseUrl: string;
+  apiKey: string;
+  api: Api;
+  headers?: Record<string, string>;
+  authHeader: boolean;
+  models: PiProviderModelConfig[];
   thinkingLevel: ThinkingLevel;
   agentDir?: string;
   authFile?: string;
-  modelsFile?: string;
+}
+
+interface PiProviderModelConfig {
+  id: string;
+  name: string;
+  api?: Api;
+  reasoning: boolean;
+  input: Array<"text" | "image">;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  contextWindow: number;
+  maxTokens: number;
+  headers?: Record<string, string>;
 }
 
 interface BuiltTools {
@@ -53,15 +75,100 @@ interface BuiltTools {
   customTools: ToolDefinition[];
 }
 
+const DEFAULT_PI_PROVIDER_NAME = "custom-openai";
+const DEFAULT_PI_PROVIDER_API = "openai-completions";
+const DEFAULT_PI_MODEL_COST = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+} as const;
+
+const PI_PROVIDER_APIS = [
+  "anthropic-messages",
+  "openai-completions",
+  "mistral-conversations",
+  "openai-responses",
+  "azure-openai-responses",
+  "openai-codex-responses",
+  "google-generative-ai",
+  "google-gemini-cli",
+  "google-vertex",
+  "bedrock-converse-stream",
+] as const;
+
+const piProviderApiSchema = z.enum(PI_PROVIDER_APIS);
+
+const piProviderModelSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1).optional(),
+  api: piProviderApiSchema.optional(),
+  reasoning: z.boolean().default(false),
+  input: z.array(z.enum(["text", "image"])).min(1).default(["text"]),
+  cost: z.object({
+    input: z.number().default(0),
+    output: z.number().default(0),
+    cacheRead: z.number().default(0),
+    cacheWrite: z.number().default(0),
+  }).default(DEFAULT_PI_MODEL_COST),
+  contextWindow: z.number().int().positive().default(128000),
+  maxTokens: z.number().int().positive().default(16384),
+  headers: z.record(z.string(), z.string()).optional(),
+});
+
 const piProviderConfigSchema = z.object({
-  provider: z.string().min(1),
+  provider: z.string().min(1).optional(),
   model: z.string().min(1),
-  thinkingLevel: z.enum(["off", "minimal", "low", "medium", "high", "xhigh"]).default("off"),
+  baseUrl: z.string().min(1),
+  apiKey: z.string().min(1),
+  api: piProviderApiSchema.optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  authHeader: z.boolean().optional(),
+  models: z.array(piProviderModelSchema).min(1).optional(),
+  thinkingLevel: z.enum(["off", "minimal", "low", "medium", "high", "xhigh"]).optional(),
   agentDir: z.string().optional(),
   authFile: z.string().optional(),
-  modelsFile: z.string().default("./models.custom.json"),
 });
 
+function buildImplicitModelConfig(modelId: string): PiProviderModelConfig {
+  return {
+    id: modelId,
+    name: modelId,
+    reasoning: false,
+    input: ["text"],
+    cost: { ...DEFAULT_PI_MODEL_COST },
+    contextWindow: 128000,
+    maxTokens: 16384,
+  };
+}
+
+function normalizePiProviderModels(
+  activeModelId: string,
+  models: Array<z.infer<typeof piProviderModelSchema>> | undefined,
+): PiProviderModelConfig[] {
+  if (!models || models.length === 0) {
+    return [buildImplicitModelConfig(activeModelId)];
+  }
+
+  const normalizedModels = models.map((model) => ({
+    id: model.id,
+    name: model.name ?? model.id,
+    ...(model.api ? { api: model.api } : {}),
+    reasoning: model.reasoning,
+    input: model.input,
+    cost: model.cost,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    ...(model.headers ? { headers: model.headers } : {}),
+  }));
+
+  if (!normalizedModels.some((model) => model.id === activeModelId)) {
+    throw new Error(`Configured model '${activeModelId}' is not present in provider.pi models`);
+  }
+
+  return normalizedModels;
+}
+
 const IMAGE_MIME_TYPES: Record<string, string> = {
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -222,7 +329,26 @@ class PiProviderInstanceImpl implements ProviderInstance {
     private readonly logger: ProviderInstanceCreateOptions["host"]["logger"],
   ) {
     this.authStorage = AuthStorage.create(providerConfig.authFile);
-    this.modelRegistry = new ModelRegistry(this.authStorage, providerConfig.modelsFile);
+    // Point the registry at a never-created file so provider.pi relies solely on inline config.
+    this.modelRegistry = new ModelRegistry(this.authStorage, join(dataConfig.stateDir, "__dobby_provider_pi_inline_models__", `${safeSegment(id)}.json`));
+    this.modelRegistry.registerProvider(providerConfig.provider, {
+      baseUrl: providerConfig.baseUrl,
+      apiKey: providerConfig.apiKey,
+      api: providerConfig.api,
+      ...(providerConfig.headers ? { headers: providerConfig.headers } : {}),
+      ...(providerConfig.authHeader ? { authHeader: true } : {}),
+      models: providerConfig.models.map((model) => ({
+        id: model.id,
+        name: model.name,
+        ...(model.api ? { api: model.api } : {}),
+        reasoning: model.reasoning,
+        input: model.input,
+        cost: model.cost,
+        contextWindow: model.contextWindow,
+        maxTokens: model.maxTokens,
+        ...(model.headers ? { headers: model.headers } : {}),
+      })),
+    });
 
     const model = this.modelRegistry.find(providerConfig.provider, providerConfig.model);
     if (!model) {
@@ -458,15 +584,19 @@ export const providerPiContribution: ProviderContributionModule = {
     const parsed = piProviderConfigSchema.parse(options.config);
     const agentDir = normalizeMaybePath(options.host.configBaseDir, parsed.agentDir);
     const authFile = normalizeMaybePath(options.host.configBaseDir, parsed.authFile);
-    const modelsFile = normalizeMaybePath(options.host.configBaseDir, parsed.modelsFile);
 
     const normalizedConfig: PiProviderConfig = {
-      provider: parsed.provider,
+      provider: parsed.provider ?? DEFAULT_PI_PROVIDER_NAME,
       model: parsed.model,
-      thinkingLevel: parsed.thinkingLevel,
+      baseUrl: parsed.baseUrl,
+      apiKey: parsed.apiKey,
+      api: parsed.api ?? DEFAULT_PI_PROVIDER_API,
+      ...(parsed.headers ? { headers: parsed.headers } : {}),
+      authHeader: parsed.authHeader ?? false,
+      models: normalizePiProviderModels(parsed.model, parsed.models),
+      thinkingLevel: parsed.thinkingLevel ?? "off",
       ...(agentDir ? { agentDir } : {}),
       ...(authFile ? { authFile } : {}),
-      ...(modelsFile ? { modelsFile } : {}),
     };
 
     return new PiProviderInstanceImpl(options.instanceId, normalizedConfig, options.data, options.host.logger);

package/src/cli/commands/doctor.ts

@@ -16,6 +16,45 @@ interface DoctorIssue {
   message: string;
 }
 
+interface PlaceholderHit {
+  path: string;
+  value: string;
+}
+
+function isPlaceholderValue(value: unknown): value is string {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const normalized = value.trim().toUpperCase();
+  return normalized.includes("REPLACE_WITH_") || normalized.includes("YOUR_");
+}
+
+function isCredentialLikeKey(key: string): boolean {
+  return /(?:token|secret|api[-_]?key|appid|appsecret)/i.test(key);
+}
+
+function walkPlaceholders(value: unknown, path: string): PlaceholderHit[] {
+  if (isPlaceholderValue(value)) {
+    return [{ path, value }];
+  }
+
+  if (Array.isArray(value)) {
+    return value.flatMap((item, index) => walkPlaceholders(item, `${path}[${index}]`));
+  }
+
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+
+  return Object.entries(value).flatMap(([key, nested]) => walkPlaceholders(nested, `${path}.${key}`));
+}
+
+function lastPathSegment(path: string): string {
+  const withoutIndexes = path.replaceAll(/\[\d+\]/g, "");
+  const segments = withoutIndexes.split(".");
+  return segments[segments.length - 1] ?? withoutIndexes;
+}
+
 function expandHome(value: string): string {
   if (value === "~") {
     return homedir();
@@ -102,6 +141,17 @@ export async function runDoctorCommand(options: {
         message: `providers.items['${instanceId}'] references missing contribution '${instance.type}'`,
       });
     }
+
+    for (const hit of walkPlaceholders(instance, `providers.items['${instanceId}']`)) {
+      if (hit.path.endsWith(".type")) {
+        continue;
+      }
+
+      issues.push({
+        level: isCredentialLikeKey(lastPathSegment(hit.path)) ? "error" : "warning",
+        message: `${hit.path} still uses placeholder value '${hit.value}'`,
+      });
+    }
   }
 
   for (const [instanceId, instance] of Object.entries(normalized.connectors.items)) {
@@ -112,6 +162,17 @@ export async function runDoctorCommand(options: {
       });
     }
 
+    for (const hit of walkPlaceholders(instance, `connectors.items['${instanceId}']`)) {
+      if (hit.path.endsWith(".type")) {
+        continue;
+      }
+
+      issues.push({
+        level: isCredentialLikeKey(lastPathSegment(hit.path)) ? "error" : "warning",
+        message: `${hit.path} still uses placeholder value '${hit.value}'`,
+      });
+    }
+
     if (instance.type === DISCORD_CONNECTOR_CONTRIBUTION_ID) {
       const botName = typeof instance.botName === "string" ? instance.botName.trim() : "";
       const botToken = typeof instance.botToken === "string" ? instance.botToken.trim() : "";
@@ -139,18 +200,51 @@ export async function runDoctorCommand(options: {
     }
   }
 
+  if (normalized.routes.default.projectRoot && isPlaceholderValue(normalized.routes.default.projectRoot)) {
+    issues.push({
+      level: "warning",
+      message: `routes.default.projectRoot still uses placeholder value '${normalized.routes.default.projectRoot}'`,
+    });
+  }
+
   for (const [routeId, route] of Object.entries(normalized.routes.items)) {
+    const effectiveProjectRoot = route.projectRoot ?? normalized.routes.default.projectRoot;
+    const projectRootSource = route.projectRoot ? `routes.items['${routeId}'].projectRoot` : "routes.default.projectRoot";
+
+    if (!effectiveProjectRoot) {
+      issues.push({
+        level: "error",
+        message: `routes.items['${routeId}'].projectRoot is required when routes.default.projectRoot is not set`,
+      });
+      continue;
+    }
+
+    if (isPlaceholderValue(effectiveProjectRoot)) {
+      issues.push({
+        level: "warning",
+        message: `${projectRootSource} still uses placeholder value '${effectiveProjectRoot}'`,
+      });
+      continue;
+    }
+
     try {
-      const projectRootPath = resolveRouteProjectRoot(configPath, route.projectRoot);
+      const projectRootPath = resolveRouteProjectRoot(configPath, effectiveProjectRoot);
       await access(projectRootPath);
     } catch {
       issues.push({
         level: "warning",
-        message: `routes.items['${routeId}'].projectRoot does not exist: ${route.projectRoot}`,
+        message: `${projectRootSource} does not exist: ${effectiveProjectRoot}`,
       });
     }
   }
 
+  if (normalized.bindings.default && !normalized.routes.items[normalized.bindings.default.route]) {
+    issues.push({
+      level: "error",
+      message: `bindings.default.route references unknown route '${normalized.bindings.default.route}'`,
+    });
+  }
+
   const seenBindingSources = new Map<string, string>();
   for (const [bindingId, binding] of Object.entries(normalized.bindings.items)) {
     if (!normalized.connectors.items[binding.connector]) {
@@ -166,6 +260,13 @@ export async function runDoctorCommand(options: {
       });
     }
 
+    if (isPlaceholderValue(binding.source.id)) {
+      issues.push({
+        level: "warning",
+        message: `bindings.items['${bindingId}'].source.id still uses placeholder value '${binding.source.id}'`,
+      });
+    }
+
     const bindingKey = `${binding.connector}:${binding.source.type}:${binding.source.id}`;
     const existingBindingId = seenBindingSources.get(bindingKey);
     if (existingBindingId) {

package/src/cli/commands/extension.ts

@@ -12,6 +12,7 @@ import {
 } from "../shared/config-mutators.js";
 import { readRawConfig, requireRawConfig, resolveConfigPath, resolveDataRootDir, writeConfigWithValidation } from "../shared/config-io.js";
 import type { RawGatewayConfig } from "../shared/config-types.js";
+import { resolveExtensionInstallSpecs } from "../shared/local-extension-specs.js";
 import { createLogger } from "../shared/runtime.js";
 
 /**
@@ -42,7 +43,8 @@ export async function runExtensionInstallCommand(options: {
 
   const rawConfig = (await readRawConfig(configPath)) ?? {};
   const manager = new ExtensionStoreManager(logger, extensionStoreDirFromRaw(configPath, rawConfig));
-  const installed = await manager.install(options.spec);
+  const [resolvedSpec] = await resolveExtensionInstallSpecs([options.spec]);
+  const installed = await manager.install(resolvedSpec ?? options.spec);
 
   if (!options.enable) {
     const templates = buildContributionTemplates(installed.manifest.contributions);