@witqq/agent-sdk 0.1.0

package/dist/backends/copilot.js

@@ -0,0 +1,647 @@
+// src/types.ts
+function getTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+
+// src/errors.ts
+var AgentSDKError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "AgentSDKError";
+  }
+};
+var ReentrancyError = class extends AgentSDKError {
+  constructor() {
+    super("Agent is already running. Await the current run before starting another.");
+    this.name = "ReentrancyError";
+  }
+};
+var DisposedError = class extends AgentSDKError {
+  constructor(entity) {
+    super(`${entity} has been disposed and cannot be used.`);
+    this.name = "DisposedError";
+  }
+};
+var SubprocessError = class extends AgentSDKError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SubprocessError";
+  }
+};
+var AbortError = class extends AgentSDKError {
+  constructor() {
+    super("Agent run was aborted.");
+    this.name = "AbortError";
+  }
+};
+
+// src/base-agent.ts
+var BaseAgent = class {
+  state = "idle";
+  abortController = null;
+  config;
+  constructor(config) {
+    this.config = Object.freeze({ ...config });
+  }
+  // ─── Public Interface ─────────────────────────────────────────
+  async run(prompt, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "running";
+    try {
+      const messages = [{ role: "user", content: prompt }];
+      return await this.executeRun(messages, options, ac.signal);
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  async runWithContext(messages, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "running";
+    try {
+      return await this.executeRun(messages, options, ac.signal);
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  async runStructured(prompt, schema, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "running";
+    try {
+      const messages = [{ role: "user", content: prompt }];
+      return await this.executeRunStructured(
+        messages,
+        schema,
+        options,
+        ac.signal
+      );
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  async *stream(prompt, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "streaming";
+    try {
+      const messages = [{ role: "user", content: prompt }];
+      yield* this.executeStream(messages, options, ac.signal);
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  abort() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  getConfig() {
+    return this.config;
+  }
+  /** Mark agent as disposed. Override to add cleanup. */
+  dispose() {
+    this.abort();
+    this.state = "disposed";
+  }
+  // ─── Guards ───────────────────────────────────────────────────
+  guardReentrancy() {
+    if (this.state === "running" || this.state === "streaming") {
+      throw new ReentrancyError();
+    }
+  }
+  guardDisposed() {
+    if (this.state === "disposed") {
+      throw new DisposedError("Agent");
+    }
+  }
+  /** Throw AbortError if signal is already aborted */
+  checkAbort(signal) {
+    if (signal.aborted) {
+      throw new AbortError();
+    }
+  }
+  // ─── Internal Helpers ─────────────────────────────────────────
+  createAbortController(externalSignal) {
+    const ac = new AbortController();
+    this.abortController = ac;
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        ac.abort();
+      } else {
+        externalSignal.addEventListener("abort", () => ac.abort(), {
+          once: true
+        });
+      }
+    }
+    return ac;
+  }
+};
+
+// src/utils/schema.ts
+function zodToJsonSchema(schema) {
+  const schemaAny = schema;
+  if ("jsonSchema" in schema && typeof schemaAny.jsonSchema === "function") {
+    return schemaAny.jsonSchema();
+  }
+  return extractSchemaFromDef(schema);
+}
+function extractSchemaFromDef(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string" };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodNull":
+      return { type: "null" };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: extractSchemaFromDef(def.type)
+      };
+    case "ZodObject": {
+      const shape = schema.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        const valueDef = value._def;
+        if (valueDef.typeName === "ZodOptional") {
+          properties[key] = extractSchemaFromDef(valueDef.innerType);
+        } else {
+          properties[key] = extractSchemaFromDef(value);
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    case "ZodOptional":
+      return extractSchemaFromDef(def.innerType);
+    case "ZodEnum":
+      return { type: "string", enum: def.values };
+    default:
+      return {};
+  }
+}
+
+// src/backends/copilot.ts
+var sdkModule = null;
+async function loadSDK() {
+  if (sdkModule) return sdkModule;
+  try {
+    sdkModule = await import('@github/copilot-sdk');
+    return sdkModule;
+  } catch {
+    throw new SubprocessError(
+      "@github/copilot-sdk is not installed. Install it: npm install @github/copilot-sdk"
+    );
+  }
+}
+function _injectSDK(mock) {
+  sdkModule = mock;
+}
+function _resetSDK() {
+  sdkModule = null;
+}
+function mapToolsToSDK(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: zodToJsonSchema(tool.parameters),
+    handler: async (args) => {
+      const result = await tool.execute(args);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    }
+  }));
+}
+function buildPermissionHandler(config) {
+  const onPermission = config.supervisor?.onPermission;
+  if (!onPermission) return void 0;
+  const permissionStore = config.permissionStore;
+  return async (request) => {
+    const toolName = String(request.kind);
+    if (permissionStore && await permissionStore.isApproved(toolName)) {
+      return { kind: "approved" };
+    }
+    const unifiedRequest = {
+      toolName,
+      toolArgs: { ...request },
+      rawSDKRequest: request
+    };
+    const ac = new AbortController();
+    const decision = await onPermission(unifiedRequest, ac.signal);
+    if (decision.allowed) {
+      if (permissionStore && decision.scope) {
+        await permissionStore.approve(toolName, decision.scope);
+      }
+      return { kind: "approved" };
+    }
+    return { kind: "denied-interactively-by-user" };
+  };
+}
+function buildUserInputHandler(config) {
+  const onAskUser = config.supervisor?.onAskUser;
+  if (!onAskUser) return void 0;
+  return async (request) => {
+    const ac = new AbortController();
+    const response = await onAskUser(
+      {
+        question: request.question,
+        choices: request.choices,
+        allowFreeform: request.allowFreeform
+      },
+      ac.signal
+    );
+    return { answer: response.answer, wasFreeform: response.wasFreeform };
+  };
+}
+var ToolCallTracker = class {
+  map = /* @__PURE__ */ new Map();
+  trackStart(toolCallId, toolName, args) {
+    this.map.set(toolCallId, { toolName, args });
+  }
+  getInfo(toolCallId) {
+    return this.map.get(toolCallId);
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+var ThinkingTracker = class {
+  active = false;
+  isActive() {
+    return this.active;
+  }
+  startThinking() {
+    this.active = true;
+  }
+  /** Returns true if thinking was active and is now ended. */
+  endThinking() {
+    if (!this.active) return false;
+    this.active = false;
+    return true;
+  }
+};
+function mapSessionEvent(event, tracker, thinkingTracker) {
+  const data = event.data;
+  switch (event.type) {
+    case "assistant.message_delta": {
+      const textEvent = {
+        type: "text_delta",
+        text: String(data.deltaContent ?? "")
+      };
+      if (thinkingTracker.endThinking()) {
+        return [{ type: "thinking_end" }, textEvent];
+      }
+      return textEvent;
+    }
+    case "assistant.reasoning":
+    case "assistant.reasoning_delta":
+      if (!thinkingTracker.isActive()) {
+        thinkingTracker.startThinking();
+        return { type: "thinking_start" };
+      }
+      return null;
+    case "tool.execution_start": {
+      const toolCallId = String(data.toolCallId ?? "");
+      const toolName = String(data.toolName ?? "unknown");
+      const args = data.arguments ?? {};
+      tracker.trackStart(toolCallId, toolName, args);
+      const toolStartEvent = { type: "tool_call_start", toolName, args };
+      if (thinkingTracker.endThinking()) {
+        return [{ type: "thinking_end" }, toolStartEvent];
+      }
+      return toolStartEvent;
+    }
+    case "tool.execution_complete": {
+      const toolCallId = String(data.toolCallId ?? "");
+      const info = tracker.getInfo(toolCallId);
+      const resultContent = data.result?.content;
+      return {
+        type: "tool_call_end",
+        toolName: info?.toolName ?? "unknown",
+        result: resultContent ?? null
+      };
+    }
+    case "assistant.usage":
+      return {
+        type: "usage_update",
+        promptTokens: Number(data.inputTokens ?? 0),
+        completionTokens: Number(data.outputTokens ?? 0)
+      };
+    case "session.error":
+      return {
+        type: "error",
+        error: String(data.message ?? "Unknown error"),
+        recoverable: false
+      };
+    case "assistant.message": {
+      const doneEvent = {
+        type: "done",
+        finalOutput: String(data.content ?? "")
+      };
+      if (thinkingTracker.endThinking()) {
+        return [{ type: "thinking_end" }, doneEvent];
+      }
+      return doneEvent;
+    }
+    default:
+      return null;
+  }
+}
+var CopilotAgent = class extends BaseAgent {
+  getClient;
+  sdkTools;
+  sessionConfig;
+  constructor(config, getClient) {
+    super(config);
+    this.getClient = getClient;
+    this.sdkTools = mapToolsToSDK(config.tools);
+    this.sessionConfig = {
+      model: config.model,
+      tools: this.sdkTools,
+      systemMessage: { mode: "replace", content: config.systemPrompt },
+      onPermissionRequest: buildPermissionHandler(config),
+      onUserInputRequest: buildUserInputHandler(config)
+    };
+  }
+  async createSession(streaming) {
+    const client = await this.getClient();
+    return client.createSession({ ...this.sessionConfig, streaming });
+  }
+  // ─── executeRun ─────────────────────────────────────────────────
+  async executeRun(messages, _options, signal) {
+    this.checkAbort(signal);
+    const session = await this.createSession(false);
+    const prompt = extractLastUserPrompt(messages);
+    const tracker = new ToolCallTracker();
+    const toolCalls = [];
+    let usage;
+    const unsubscribe = session.on((event) => {
+      if (event.type === "tool.execution_start") {
+        tracker.trackStart(
+          String(event.data.toolCallId ?? ""),
+          String(event.data.toolName ?? "unknown"),
+          event.data.arguments ?? {}
+        );
+      }
+      if (event.type === "tool.execution_complete") {
+        const info = tracker.getInfo(String(event.data.toolCallId ?? ""));
+        const resultContent = event.data.result?.content;
+        toolCalls.push({
+          toolName: info?.toolName ?? "unknown",
+          args: info?.args ?? {},
+          result: resultContent ?? null,
+          approved: Boolean(event.data.success ?? true)
+        });
+      }
+      if (event.type === "assistant.usage") {
+        usage = {
+          promptTokens: Number(event.data.inputTokens ?? 0),
+          completionTokens: Number(event.data.outputTokens ?? 0)
+        };
+      }
+    });
+    const onAbort = () => {
+      session.abort().catch(() => {
+      });
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      const response = await session.sendAndWait({ prompt });
+      const output = response?.data?.content ?? null;
+      return {
+        output,
+        structuredOutput: void 0,
+        toolCalls,
+        messages: [
+          ...messages,
+          ...output !== null ? [{ role: "assistant", content: output }] : []
+        ],
+        usage
+      };
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+      unsubscribe();
+      tracker.clear();
+      session.destroy().catch(() => {
+      });
+    }
+  }
+  // ─── executeRunStructured ───────────────────────────────────────
+  async executeRunStructured(messages, schema, options, signal) {
+    const jsonSchema = zodToJsonSchema(schema.schema);
+    const instruction = `
+
+You MUST respond with ONLY valid JSON matching this schema:
+` + JSON.stringify(jsonSchema, null, 2);
+    const augmented = [...messages];
+    const lastIdx = augmented.length - 1;
+    if (lastIdx >= 0 && augmented[lastIdx].role === "user") {
+      const orig = augmented[lastIdx];
+      augmented[lastIdx] = {
+        role: "user",
+        content: getTextContent(orig.content) + instruction
+      };
+    }
+    const result = await this.executeRun(augmented, options, signal);
+    let structuredOutput;
+    if (result.output) {
+      try {
+        const jsonMatch = result.output.match(
+          /```(?:json)?\s*([\s\S]*?)```/
+        );
+        const raw = jsonMatch ? jsonMatch[1].trim() : result.output.trim();
+        structuredOutput = schema.schema.parse(JSON.parse(raw));
+      } catch {
+      }
+    }
+    return {
+      ...result,
+      structuredOutput
+    };
+  }
+  // ─── executeStream ──────────────────────────────────────────────
+  async *executeStream(messages, _options, signal) {
+    this.checkAbort(signal);
+    const session = await this.createSession(true);
+    const prompt = extractLastUserPrompt(messages);
+    const tracker = new ToolCallTracker();
+    const thinkingTracker = new ThinkingTracker();
+    const queue = [];
+    let notify = null;
+    const push = (item) => {
+      queue.push(item);
+      if (notify) {
+        notify();
+        notify = null;
+      }
+    };
+    const waitForItem = () => new Promise((resolve) => {
+      notify = resolve;
+    });
+    const unsubscribe = session.on((event) => {
+      const mapped = mapSessionEvent(event, tracker, thinkingTracker);
+      if (mapped) {
+        if (Array.isArray(mapped)) {
+          for (const e of mapped) push({ event: e });
+        } else {
+          push({ event: mapped });
+        }
+      }
+      if (event.type === "session.idle") {
+        push({ done: true });
+      } else if (event.type === "session.error") {
+        push({
+          error: new Error(
+            String(event.data.message ?? "Session error")
+          )
+        });
+      }
+    });
+    const onAbort = () => {
+      session.abort().catch(() => {
+      });
+      push({ error: new AbortError() });
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      await session.send({ prompt });
+      while (true) {
+        while (queue.length === 0) await waitForItem();
+        const item = queue.shift();
+        if ("done" in item) break;
+        if ("error" in item) throw item.error;
+        yield item.event;
+      }
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+      unsubscribe();
+      tracker.clear();
+      session.destroy().catch(() => {
+      });
+    }
+  }
+  // ─── dispose ────────────────────────────────────────────────────
+  dispose() {
+    super.dispose();
+  }
+};
+function extractLastUserPrompt(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      return getTextContent(msg.content);
+    }
+  }
+  return "";
+}
+var CopilotAgentService = class {
+  name = "copilot";
+  client = null;
+  clientPromise = null;
+  disposed = false;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async ensureClient() {
+    if (this.disposed) throw new DisposedError("CopilotAgentService");
+    if (this.client) return this.client;
+    if (this.clientPromise) return this.clientPromise;
+    this.clientPromise = (async () => {
+      try {
+        const sdk = await loadSDK();
+        const client = new sdk.CopilotClient({
+          cliPath: this.options.cliPath,
+          cwd: this.options.workingDirectory,
+          useStdio: true,
+          autoStart: false,
+          autoRestart: true,
+          logLevel: "error",
+          githubToken: this.options.githubToken,
+          useLoggedInUser: this.options.useLoggedInUser ?? true
+        });
+        await client.start();
+        this.client = client;
+        return client;
+      } catch (e) {
+        this.clientPromise = null;
+        throw e;
+      }
+    })();
+    return this.clientPromise;
+  }
+  createAgent(config) {
+    if (this.disposed) throw new DisposedError("CopilotAgentService");
+    return new CopilotAgent(config, () => this.ensureClient());
+  }
+  async listModels() {
+    const client = await this.ensureClient();
+    const models = await client.listModels();
+    return models.map((m) => ({
+      id: m.id,
+      name: m.name,
+      provider: "copilot"
+    }));
+  }
+  async validate() {
+    const errors = [];
+    try {
+      const client = await this.ensureClient();
+      const auth = await client.getAuthStatus();
+      if (!auth.isAuthenticated) {
+        errors.push(
+          "Not authenticated with GitHub Copilot. Run 'copilot auth login'."
+        );
+      }
+    } catch (e) {
+      errors.push(
+        `Failed to connect to Copilot CLI: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    if (this.clientPromise) {
+      try {
+        await this.clientPromise;
+      } catch {
+      }
+    }
+    if (this.client) {
+      await this.client.stop();
+      this.client = null;
+    }
+    this.clientPromise = null;
+  }
+};
+function createCopilotService(options) {
+  return new CopilotAgentService(options);
+}
+
+export { _injectSDK, _resetSDK, createCopilotService };
+//# sourceMappingURL=copilot.js.map
+//# sourceMappingURL=copilot.js.map