@corbat-tech/coco 2.24.1 → 2.25.0

package/dist/index.d.ts

@@ -580,6 +580,15 @@ declare const CocoConfigSchema: z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        defaultTimeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        autoDiscover: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        logLevel: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            debug: "debug";
+            warn: "warn";
+        }>>>;
+        customServersPath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     tools: z.ZodOptional<z.ZodObject<{
         webSearch: z.ZodOptional<z.ZodObject<{
@@ -621,7 +630,9 @@ declare const CocoConfigSchema: z.ZodObject<{
     skills: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         globalDir: z.ZodOptional<z.ZodString>;
+        globalDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
         projectDir: z.ZodOptional<z.ZodString>;
+        projectDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
         autoActivate: z.ZodDefault<z.ZodBoolean>;
         maxActiveSkills: z.ZodDefault<z.ZodNumber>;
         disabled: z.ZodDefault<z.ZodArray<z.ZodString>>;

package/dist/index.js

@@ -625,7 +625,15 @@ var init_schema = __esm({
       enabled: z.boolean().default(true),
       configFile: z.string().optional(),
       // Path to external MCP config file
-      servers: z.array(MCPServerConfigEntrySchema).default([])
+      servers: z.array(MCPServerConfigEntrySchema).default([]),
+      /** Default timeout for MCP requests in milliseconds */
+      defaultTimeout: z.number().min(1e3).default(6e4).optional(),
+      /** Auto-discover MCP servers from well-known locations */
+      autoDiscover: z.boolean().default(true).optional(),
+      /** Log level for MCP operations */
+      logLevel: z.enum(["debug", "info", "warn", "error"]).default("info").optional(),
+      /** Path to custom servers directory */
+      customServersPath: z.string().optional()
     });
     ToolsConfigSchema = z.object({
       webSearch: z.object({
@@ -668,8 +676,12 @@ var init_schema = __esm({
       enabled: z.boolean().default(true),
       /** Override global skills directory */
       globalDir: z.string().optional(),
+      /** Override global skills directories (preferred over globalDir) */
+      globalDirs: z.array(z.string()).optional(),
       /** Override project skills directory */
       projectDir: z.string().optional(),
+      /** Override project skills directories (preferred over projectDir) */
+      projectDirs: z.array(z.string()).optional(),
       /** Auto-activate skills based on user messages */
       autoActivate: z.boolean().default(true),
       /** Maximum concurrent active markdown skills */
@@ -739,11 +751,15 @@ var init_paths = __esm({
       /** Search index directory: ~/.coco/search-index/ */
       searchIndex: join(COCO_HOME, "search-index"),
       /** Global skills directory: ~/.coco/skills/ */
-      skills: join(COCO_HOME, "skills")
+      skills: join(COCO_HOME, "skills"),
+      /** MCP server registry: ~/.coco/mcp.json */
+      mcpRegistry: join(COCO_HOME, "mcp.json")
     };
     ({
       /** Old config location */
-      oldConfig: join(homedir(), ".config", "corbat-coco")
+      oldConfig: join(homedir(), ".config", "corbat-coco"),
+      /** Old MCP config directory (pre-unification) */
+      oldMcpDir: join(homedir(), ".config", "coco", "mcp")
     });
   }
 });
@@ -14248,7 +14264,9 @@ var OpenAIProvider = class {
               break;
             case "response.completed":
               {
+                const emittedCallIds = /* @__PURE__ */ new Set();
                 for (const toolCall of toolCallAssembler.finalizeAll(this.name)) {
+                  if (toolCall.id) emittedCallIds.add(toolCall.id);
                   yield {
                     type: "tool_use_end",
                     toolCall: {
@@ -14258,9 +14276,20 @@ var OpenAIProvider = class {
                     }
                   };
                 }
-                const hasToolCalls = event.response.output.some(
-                  (i) => i.type === "function_call"
-                );
+                const outputItems = event.response?.output ?? [];
+                for (const item of outputItems) {
+                  if (item.type !== "function_call" || !item.call_id || !item.name) continue;
+                  if (emittedCallIds.has(item.call_id)) continue;
+                  yield {
+                    type: "tool_use_end",
+                    toolCall: {
+                      id: item.call_id,
+                      name: item.name,
+                      input: parseToolCallArguments(item.arguments ?? "{}", this.name)
+                    }
+                  };
+                }
+                const hasToolCalls = outputItems.some((i) => i.type === "function_call");
                 yield {
                   type: "done",
                   stopReason: hasToolCalls ? "tool_use" : "end_turn"
@@ -14874,6 +14903,8 @@ var CodexProvider = class {
     const decoder = new TextDecoder();
     let buffer = "";
     const toolCallAssembler = new ResponsesToolCallAssembler();
+    const emittedToolCallIds = /* @__PURE__ */ new Set();
+    const emittedToolCallSignatures = /* @__PURE__ */ new Set();
     let lastActivityTime = Date.now();
     const timeoutController = new AbortController();
     const timeoutInterval = setInterval(() => {
@@ -14936,6 +14967,9 @@ var CodexProvider = class {
                 this.name
               );
               if (toolCall) {
+                if (toolCall.id) emittedToolCallIds.add(toolCall.id);
+                const signature = `${toolCall.name}:${JSON.stringify(toolCall.input ?? {})}`;
+                emittedToolCallSignatures.add(signature);
                 yield {
                   type: "tool_use_end",
                   toolCall: {
@@ -14949,6 +14983,9 @@ var CodexProvider = class {
             }
             case "response.completed": {
               for (const toolCall of toolCallAssembler.finalizeAll(this.name)) {
+                if (toolCall.id) emittedToolCallIds.add(toolCall.id);
+                const signature = `${toolCall.name}:${JSON.stringify(toolCall.input ?? {})}`;
+                emittedToolCallSignatures.add(signature);
                 yield {
                   type: "tool_use_end",
                   toolCall: {
@@ -14958,8 +14995,26 @@ var CodexProvider = class {
                   }
                 };
               }
-              const resp = event.response;
-              const output = resp?.output ?? [];
+              const responsePayload = event.response;
+              const output = responsePayload?.output ?? [];
+              for (const item of output) {
+                if (item.type !== "function_call" || !item.call_id || !item.name) continue;
+                const parsedInput = parseToolCallArguments(item.arguments ?? "{}", this.name);
+                const signature = `${item.name}:${JSON.stringify(parsedInput ?? {})}`;
+                if (emittedToolCallIds.has(item.call_id) || emittedToolCallSignatures.has(signature)) {
+                  continue;
+                }
+                emittedToolCallIds.add(item.call_id);
+                emittedToolCallSignatures.add(signature);
+                yield {
+                  type: "tool_use_end",
+                  toolCall: {
+                    id: item.call_id,
+                    name: item.name,
+                    input: parsedInput
+                  }
+                };
+              }
               const hasToolCalls = output.some((i) => i.type === "function_call");
               yield {
                 type: "done",