@lobu/worker 3.0.9 → 3.0.12

package/src/openclaw/instructions.ts

@@ -1,38 +0,0 @@
-import {
-  type InstructionContext,
-  type InstructionProvider,
-  renderAlwaysOnToolPolicyRules,
-  renderBaselineAgentPolicy,
-  renderDetectedToolIntentRules,
-} from "@lobu/core";
-
-/**
- * OpenClaw core instructions
- */
-export class OpenClawCoreInstructionProvider implements InstructionProvider {
-  name = "core";
-  priority = 10;
-
-  getInstructions(context: InstructionContext): string {
-    return [
-      `You are a Lobu agent for user ${context.userId}.`,
-      `Working directory: ${context.workingDirectory}`,
-      renderBaselineAgentPolicy(),
-      renderAlwaysOnToolPolicyRules(),
-      `## Image Analysis
-
-If the user asks to analyze an uploaded image, use the image content already attached to the prompt and provide direct analysis.`,
-    ].join("\n\n");
-  }
-}
-
-export class OpenClawPromptIntentInstructionProvider
-  implements InstructionProvider
-{
-  name = "prompt-intent";
-  priority = 15;
-
-  getInstructions(context: InstructionContext): string {
-    return renderDetectedToolIntentRules(context.userPrompt || "");
-  }
-}

package/src/openclaw/model-resolver.ts

@@ -1,150 +0,0 @@
-/**
- * Model resolution and session management helpers.
- * Extracted from worker.ts for clarity.
- */
-
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { type ConfigProviderMeta, createLogger } from "@lobu/core";
-import { SessionManager } from "@mariozechner/pi-coding-agent";
-
-const logger = createLogger("model-resolver");
-
-/** Hardcoded fallback map for provider base URL env vars. */
-export const DEFAULT_PROVIDER_BASE_URL_ENV: Record<string, string> = {
-  anthropic: "ANTHROPIC_BASE_URL",
-  openai: "OPENAI_BASE_URL",
-  "openai-codex": "OPENAI_BASE_URL",
-  google: "GEMINI_API_BASE_URL",
-  nvidia: "NVIDIA_API_BASE_URL",
-  "z-ai": "Z_AI_API_BASE_URL",
-};
-
-/** Default model IDs per provider, used when no explicit model is configured. */
-export const DEFAULT_PROVIDER_MODELS: Record<string, string> = {
-  anthropic: "claude-sonnet-4-20250514",
-  openai: "gpt-4.1",
-  "openai-codex": "gpt-5.1-codex-max",
-  google: "gemini-2.5-pro",
-  nvidia: "nvidia/moonshotai/kimi-k2.5",
-  "z-ai": "glm-4.7",
-};
-
-/**
- * Map gateway provider slugs to model-registry provider names.
- * The gateway uses slugs like "z-ai" while the model registry uses "zai".
- */
-export const PROVIDER_REGISTRY_ALIASES: Record<string, string> = {
-  "z-ai": "zai",
-};
-
-/**
- * Register a config-driven provider at runtime.
- * Extends the base URL env, default model, and registry alias maps
- * so resolveModelRef() and the worker can handle the provider.
- */
-export function registerDynamicProvider(
-  id: string,
-  config: ConfigProviderMeta
-): void {
-  const alreadyRegistered = !!DEFAULT_PROVIDER_BASE_URL_ENV[id];
-
-  if (!alreadyRegistered) {
-    DEFAULT_PROVIDER_BASE_URL_ENV[id] = config.baseUrlEnvVar;
-  }
-
-  // Always update default model and alias even for pre-registered providers
-  if (config.defaultModel && !DEFAULT_PROVIDER_MODELS[id]) {
-    DEFAULT_PROVIDER_MODELS[id] = config.defaultModel;
-  }
-
-  // Map to model registry name: explicit alias, or "openai" for sdkCompat providers
-  if (!PROVIDER_REGISTRY_ALIASES[id]) {
-    const alias =
-      config.registryAlias ||
-      (config.sdkCompat === "openai" ? "openai" : undefined);
-    if (alias) {
-      PROVIDER_REGISTRY_ALIASES[id] = alias;
-    }
-  }
-
-  if (alreadyRegistered) return;
-
-  logger.info(
-    `Registered dynamic provider: ${id} (baseUrlEnv=${config.baseUrlEnvVar}, sdkCompat=${config.sdkCompat || "none"})`
-  );
-}
-
-export function resolveModelRef(
-  rawModelRef: string,
-  overrides?: { defaultModel?: string; defaultProvider?: string }
-): {
-  provider: string;
-  modelId: string;
-} {
-  const defaultModelRef =
-    overrides?.defaultModel || process.env.AGENT_DEFAULT_MODEL || "";
-  const defaultProvider =
-    overrides?.defaultProvider || process.env.AGENT_DEFAULT_PROVIDER || "";
-
-  const normalizedRaw = rawModelRef?.trim();
-  let modelRef = normalizedRaw || defaultModelRef;
-
-  // When no model is configured but a provider is known, use the provider's
-  // default model so auto-mode provider selection works end-to-end.
-  if (!modelRef && defaultProvider) {
-    const fallbackModel = DEFAULT_PROVIDER_MODELS[defaultProvider];
-    if (fallbackModel) {
-      logger.info(
-        `No model configured, using default for ${defaultProvider}: ${fallbackModel}`
-      );
-      modelRef = fallbackModel;
-    }
-  }
-
-  if (!modelRef) {
-    throw new Error(
-      "No model configured. Ask an admin to connect a provider for the base agent."
-    );
-  }
-
-  const parts = modelRef.split("/").filter(Boolean);
-  if (parts.length >= 2) {
-    const provider = parts[0]!;
-    let modelId = parts.slice(1).join("/");
-    // Resolve "auto" to the provider's default model
-    if (modelId === "auto") {
-      const fallback = DEFAULT_PROVIDER_MODELS[provider];
-      if (fallback) {
-        logger.info(`Resolved auto model for ${provider}: ${fallback}`);
-        modelId = fallback;
-      }
-    }
-    return { provider, modelId };
-  }
-
-  if (!defaultProvider) {
-    throw new Error(
-      `No provider specified for model "${modelRef}". Use "provider/model" format or set AGENT_DEFAULT_PROVIDER.`
-    );
-  }
-
-  return { provider: defaultProvider, modelId: modelRef };
-}
-
-export async function openOrCreateSessionManager(
-  sessionFile: string,
-  workspaceDir: string
-): Promise<SessionManager> {
-  try {
-    await fs.stat(sessionFile);
-    return SessionManager.open(sessionFile);
-  } catch {
-    const sessionManager = SessionManager.create(
-      workspaceDir,
-      path.dirname(sessionFile)
-    );
-    sessionManager.setSessionFile(sessionFile);
-    return sessionManager;
-  }
-}

package/src/openclaw/plugin-loader.ts

@@ -1,427 +0,0 @@
-/**
- * OpenClaw plugin loader.
- *
- * Loads plugin modules by dynamic import and provides a compatibility shim.
- * Supports both legacy function-style plugins and object-style plugins with
- * a `register(api)` method.
- */
-
-import {
-  createLogger,
-  type PluginConfig,
-  type PluginManifest,
-  type PluginsConfig,
-  type ProviderRegistration,
-} from "@lobu/core";
-import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
-
-const logger = createLogger("openclaw-plugin-loader");
-
-type PluginHookName = "before_agent_start" | "agent_end";
-
-export type PluginHookHandler = (
-  event: Record<string, unknown>,
-  ctx: Record<string, unknown>
-) => unknown | Promise<unknown>;
-
-export interface PluginService {
-  id: string;
-  start?: () => unknown | Promise<unknown>;
-  stop?: () => unknown | Promise<unknown>;
-}
-
-/** Result of loading a single plugin */
-export interface LoadedPlugin {
-  manifest: PluginManifest;
-  /** Raw ToolDefinition objects captured from registerTool() — no bridging needed */
-  tools: ToolDefinition[];
-  providers: ProviderRegistration[];
-  hooks: Record<PluginHookName, PluginHookHandler[]>;
-  services: PluginService[];
-}
-
-/**
- * Load all enabled plugins from config.
- */
-export async function loadPlugins(
-  config: PluginsConfig | undefined,
-  cwd?: string
-): Promise<LoadedPlugin[]> {
-  if (!config?.plugins?.length) {
-    return [];
-  }
-
-  const enabledPlugins = config.plugins.filter((p) => p.enabled !== false);
-  if (enabledPlugins.length === 0) {
-    return [];
-  }
-
-  logger.info(`Loading ${enabledPlugins.length} plugin(s)`);
-
-  const results: LoadedPlugin[] = [];
-
-  for (const pluginConfig of enabledPlugins) {
-    try {
-      const loaded = await loadSinglePlugin(pluginConfig, cwd);
-      if (loaded) {
-        results.push(loaded);
-        const parts = [];
-        if (loaded.tools.length > 0)
-          parts.push(`${loaded.tools.length} tool(s)`);
-        if (loaded.providers.length > 0)
-          parts.push(`${loaded.providers.length} provider(s)`);
-        const hookCount =
-          loaded.hooks.before_agent_start.length +
-          loaded.hooks.agent_end.length;
-        if (hookCount > 0) parts.push(`${hookCount} hook(s)`);
-        if (loaded.services.length > 0)
-          parts.push(`${loaded.services.length} service(s)`);
-        logger.info(
-          `Loaded plugin "${loaded.manifest.name}" with ${parts.join(", ") || "no registrations"}`
-        );
-      }
-    } catch (err) {
-      logger.error(
-        `Failed to load plugin "${pluginConfig.source}": ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-
-  return results;
-}
-
-/**
- * Load a single plugin by resolving its module and invoking its factory.
- */
-async function loadSinglePlugin(
-  config: PluginConfig,
-  cwd?: string
-): Promise<LoadedPlugin | null> {
-  const { source, slot, config: pluginConfig } = config;
-
-  let mod: Record<string, unknown>;
-  try {
-    mod = (await import(source)) as Record<string, unknown>;
-  } catch (err) {
-    throw new Error(
-      `Cannot import "${source}": ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-
-  const pluginEntrypoint = resolvePluginEntrypoint(mod);
-  if (!pluginEntrypoint) {
-    logger.warn(`Plugin "${source}" has no registerable entrypoint - skipping`);
-    return null;
-  }
-
-  const capturedTools: ToolDefinition[] = [];
-  const capturedProviders: ProviderRegistration[] = [];
-  const capturedHooks: Record<PluginHookName, PluginHookHandler[]> = {
-    before_agent_start: [],
-    agent_end: [],
-  };
-  const capturedServices: PluginService[] = [];
-  const shimApi = createShimApi({
-    source,
-    pluginConfig: pluginConfig ?? {},
-    capturedTools,
-    capturedProviders,
-    capturedHooks,
-    capturedServices,
-    cwd,
-  });
-
-  await Promise.resolve(pluginEntrypoint.register(shimApi));
-  const pluginName =
-    readStringProperty(pluginEntrypoint.metadata, "name") ||
-    extractPluginName(source);
-
-  return {
-    manifest: {
-      source,
-      slot,
-      name: pluginName,
-    },
-    tools: capturedTools,
-    providers: capturedProviders,
-    hooks: capturedHooks,
-    services: capturedServices,
-  };
-}
-
-/**
- * Resolve plugin entrypoint from module exports.
- * Supports:
- * - default export function (legacy)
- * - default export object with register(api)
- * - named register/init functions
- */
-function resolvePluginEntrypoint(mod: Record<string, unknown>): {
-  register: (api: unknown) => void | Promise<void>;
-  metadata?: Record<string, unknown>;
-} | null {
-  const defaultExport = mod.default;
-  if (typeof defaultExport === "function") {
-    return {
-      register: defaultExport as (api: unknown) => void | Promise<void>,
-    };
-  }
-
-  if (isRecord(defaultExport) && typeof defaultExport.register === "function") {
-    return {
-      register: defaultExport.register as (
-        api: unknown
-      ) => void | Promise<void>,
-      metadata: defaultExport,
-    };
-  }
-
-  for (const name of ["register", "init"]) {
-    const fn = mod[name];
-    if (typeof fn === "function") {
-      return {
-        register: fn as (api: unknown) => void | Promise<void>,
-      };
-    }
-  }
-
-  return null;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-function readStringProperty(
-  obj: Record<string, unknown> | undefined,
-  key: string
-): string | undefined {
-  if (!obj) return undefined;
-  const value = obj[key];
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-/**
- * Create a shim API that captures tool/provider/hook/service registrations.
- * Non-worker capabilities are no-oped for compatibility.
- */
-function createShimApi(params: {
-  source: string;
-  pluginConfig: Record<string, unknown>;
-  capturedTools: ToolDefinition[];
-  capturedProviders: ProviderRegistration[];
-  capturedHooks: Record<PluginHookName, PluginHookHandler[]>;
-  capturedServices: PluginService[];
-  cwd?: string;
-}): Record<string, unknown> {
-  const {
-    source,
-    pluginConfig,
-    capturedTools,
-    capturedProviders,
-    capturedHooks,
-    capturedServices,
-    cwd,
-  } = params;
-  const noop = () => {
-    /* intentional no-op */
-  };
-
-  const shimLogger = {
-    info(message: string, ...args: unknown[]) {
-      logger.info(`[plugin:${extractPluginName(source)}] ${message}`, ...args);
-    },
-    warn(message: string, ...args: unknown[]) {
-      logger.warn(`[plugin:${extractPluginName(source)}] ${message}`, ...args);
-    },
-    error(message: string, ...args: unknown[]) {
-      logger.error(`[plugin:${extractPluginName(source)}] ${message}`, ...args);
-    },
-    debug(message: string, ...args: unknown[]) {
-      logger.debug(`[plugin:${extractPluginName(source)}] ${message}`, ...args);
-    },
-  };
-
-  return {
-    pluginConfig,
-    logger: shimLogger,
-
-    on(eventName: unknown, handler: unknown) {
-      if (
-        (eventName === "before_agent_start" || eventName === "agent_end") &&
-        typeof handler === "function"
-      ) {
-        capturedHooks[eventName].push(handler as PluginHookHandler);
-        return;
-      }
-      logger.debug(
-        `Plugin "${source}" registered unsupported hook "${String(eventName)}"`
-      );
-    },
-
-    // Capture tool registrations as-is (full ToolDefinition passthrough)
-    registerTool(toolDef: Record<string, unknown>) {
-      if (
-        typeof toolDef.name !== "string" ||
-        typeof toolDef.description !== "string" ||
-        typeof toolDef.execute !== "function"
-      ) {
-        logger.warn(
-          "Plugin registered invalid tool - missing name, description, or execute"
-        );
-        return;
-      }
-
-      // Store the full ToolDefinition object — name, label, description,
-      // parameters, execute, renderCall, renderResult all preserved.
-      capturedTools.push(toolDef as unknown as ToolDefinition);
-    },
-
-    // Capture provider registrations (passed through to ModelRegistry)
-    registerProvider(name: unknown, config: unknown) {
-      if (typeof name !== "string" || !name.trim()) {
-        logger.warn("Plugin registered provider with invalid name");
-        return;
-      }
-      if (typeof config !== "object" || config === null) {
-        logger.warn(`Plugin registered provider "${name}" with invalid config`);
-        return;
-      }
-
-      capturedProviders.push({
-        name: name.trim(),
-        config: config as Record<string, unknown>,
-      });
-    },
-
-    registerService(service: unknown) {
-      if (!isRecord(service)) {
-        logger.warn(`Plugin "${source}" registered invalid service`);
-        return;
-      }
-      const id = readStringProperty(service, "id");
-      if (!id) {
-        logger.warn(`Plugin "${source}" registered service without valid id`);
-        return;
-      }
-      const start =
-        typeof service.start === "function"
-          ? (service.start as () => unknown | Promise<unknown>)
-          : undefined;
-      const stop =
-        typeof service.stop === "function"
-          ? (service.stop as () => unknown | Promise<unknown>)
-          : undefined;
-      capturedServices.push({ id, start, stop });
-    },
-
-    // No-op compatibility methods (worker runtime does not expose these surfaces)
-    registerCli: noop,
-    registerCommand: noop,
-    registerShortcut: noop,
-    registerFlag: noop,
-    registerChannel: noop,
-    registerMessageRenderer: noop,
-    sendMessage: noop,
-    sendUserMessage: noop,
-    appendEntry: noop,
-    setSessionName: noop,
-    getSessionName: () => undefined,
-    setLabel: noop,
-    exec: async () => ({
-      exitCode: 1,
-      stdout: "",
-      stderr: "exec is not supported in Lobu worker plugin shim",
-    }),
-    getActiveTools: () => [] as string[],
-    getAllTools: () => [] as Array<{ name: string; description: string }>,
-    setActiveTools: noop,
-    getCommands: () => [] as unknown[],
-    setModel: async () => false,
-    getThinkingLevel: () => "medium",
-    setThinkingLevel: noop,
-    events: {
-      on: noop,
-      off: noop,
-      emit: noop,
-    },
-
-    // Expose minimal context that plugins might read
-    cwd: cwd || process.cwd(),
-  };
-}
-
-export async function runPluginHooks(params: {
-  plugins: LoadedPlugin[];
-  hook: PluginHookName;
-  event: Record<string, unknown>;
-  ctx: Record<string, unknown>;
-}): Promise<unknown[]> {
-  const { plugins, hook, event, ctx } = params;
-  const results: unknown[] = [];
-  for (const plugin of plugins) {
-    const handlers = plugin.hooks[hook];
-    if (handlers.length === 0) continue;
-
-    for (const handler of handlers) {
-      try {
-        const result = await Promise.resolve(handler(event, ctx));
-        results.push(result);
-      } catch (err) {
-        logger.error(
-          `Plugin hook "${hook}" failed for "${plugin.manifest.name}": ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  }
-  return results;
-}
-
-export async function startPluginServices(
-  plugins: LoadedPlugin[]
-): Promise<void> {
-  for (const plugin of plugins) {
-    for (const service of plugin.services) {
-      if (!service.start) continue;
-      try {
-        await Promise.resolve(service.start());
-      } catch (err) {
-        logger.error(
-          `Plugin service "${service.id}" failed to start (${plugin.manifest.name}): ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  }
-}
-
-export async function stopPluginServices(
-  plugins: LoadedPlugin[]
-): Promise<void> {
-  for (const plugin of [...plugins].reverse()) {
-    for (const service of [...plugin.services].reverse()) {
-      if (!service.stop) continue;
-      try {
-        await Promise.resolve(service.stop());
-      } catch (err) {
-        logger.error(
-          `Plugin service "${service.id}" failed to stop (${plugin.manifest.name}): ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  }
-}
-
-/**
- * Extract a display name from a plugin source string.
- * "@openclaw/voice-call" -> "voice-call"
- * "./my-plugin" -> "my-plugin"
- */
-function extractPluginName(source: string): string {
-  const scopeMatch = source.match(/^@[^/]+\/(.+)$/);
-  if (scopeMatch?.[1]) {
-    return scopeMatch[1];
-  }
-
-  const parts = source.split("/");
-  return parts[parts.length - 1] || source;
-}