@kosuke-ai/cli 6.7.0 → 6.9.0

package/dist/integrations/api.js

@@ -0,0 +1,135 @@
+import { ResponseTooLarge } from '../runtime/client.js';
+/**
+ * The integration tools routes, read the way a command prints them. Everything
+ * the platform sends is text from a connected third party or a user's label, so
+ * it is flattened to bounded one-liners here and never interpreted.
+ */
+export const TOOLS_PATH = '/api/agent-integrations/tools';
+const UNAVAILABLE = 'Integration tools are temporarily unavailable.';
+const TOO_LARGE = 'The platform answer was too large to read. Narrow the request.';
+const TIMED_OUT = 'The platform did not answer in time.';
+/** A write may have landed before the connection failed; a retry could repeat it. */
+const UNKNOWN_OUTCOME = 'The integration tool call did not complete and its outcome is unknown. Do not retry it; read the current state first.';
+export const isRow = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export const rowsOf = (value) => (Array.isArray(value) ? value.filter(isRow) : []);
+/** One bounded line: control characters and runs of space become one space. */
+export function oneLine(value, max) {
+    if (typeof value !== 'string')
+        return '';
+    const flat = value.replace(/[\p{Cc}\p{Cf}\s]+/gu, ' ').trim();
+    return flat.length > max ? `${flat.slice(0, max - 1).trimEnd()}…` : flat;
+}
+const count = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
+export function connectionOf(row) {
+    const id = oneLine(row.id, 16);
+    const alias = oneLine(row.alias, 80);
+    if (!alias)
+        return null;
+    return {
+        id,
+        alias,
+        scope: row.scope === 'personal' ? 'personal' : 'workspace',
+        label: oneLine(row.label, 60),
+        accountIdentity: oneLine(row.accountIdentity, 80) || null,
+    };
+}
+/** `data` of a `view=overview` answer, or null for any other shape (an older platform's). */
+function parseOverview(data) {
+    if (!isRow(data) || data.view !== 'overview' || !Array.isArray(data.toolkits))
+        return null;
+    const toolkits = rowsOf(data.toolkits).map((row) => {
+        const tools = isRow(row.tools) ? row.tools : {};
+        const toolkit = oneLine(row.toolkit, 64);
+        return {
+            toolkit,
+            name: oneLine(row.name, 60) || toolkit,
+            connections: rowsOf(row.connections).flatMap((connection) => connectionOf(connection) ?? []),
+            read: count(tools.read),
+            write: count(tools.write),
+        };
+    });
+    const tools = Array.isArray(data.tools)
+        ? rowsOf(data.tools).map((row) => ({
+            name: oneLine(row.name, 80),
+            toolkit: oneLine(row.toolkit, 64),
+            access: row.access === 'read' ? 'read' : 'write',
+            description: oneLine(row.description, 160),
+            aliases: (Array.isArray(row.aliases) ? row.aliases : [])
+                .map((alias) => oneLine(alias, 80))
+                .filter(Boolean),
+        }))
+        : null;
+    return {
+        toolkits,
+        connectionTotal: count(data.connectionTotal),
+        tools,
+        toolTotal: tools ? count(data.toolTotal) : null,
+        note: oneLine(data.note, 400) || null,
+    };
+}
+/** The platform's own sentence for a refusal, bounded; its status when it said nothing. */
+function sentenceOf(error, status) {
+    const said = isRow(error) ? oneLine(error.error, 300) : '';
+    return said || `HTTP ${status}`;
+}
+/**
+ * Why a request failed, in words the reader can act on. The 4xx sentences are
+ * the platform's own (a Connector Token, a workspace the key is not a member of,
+ * Slack triage); only 401 and 429 are worded here.
+ */
+export function failureOf(status, error, method) {
+    // A gateway answering for the app does not prove the app never ran the write.
+    if (method === 'POST' && (status === 502 || status === 504)) {
+        return { ok: false, status, message: UNKNOWN_OUTCOME };
+    }
+    if (status === 401) {
+        return {
+            ok: false,
+            status,
+            message: 'The API key was refused (HTTP 401). Run `kosuke auth status`.',
+        };
+    }
+    if (status === 429) {
+        return { ok: false, status, message: 'Too many requests. Try again shortly.' };
+    }
+    if (status >= 400 && status < 500) {
+        return { ok: false, status, message: sentenceOf(error, status) };
+    }
+    return { ok: false, status, message: UNAVAILABLE };
+}
+/** A request that never got an answer. */
+export function transportFailure(error, method) {
+    const name = error instanceof Error ? error.name : '';
+    if (method === 'GET' && error instanceof ResponseTooLarge) {
+        return { ok: false, status: null, message: TOO_LARGE };
+    }
+    const timedOut = name === 'TimeoutError' || name === 'AbortError';
+    if (method === 'POST')
+        return { ok: false, status: null, message: UNKNOWN_OUTCOME };
+    return { ok: false, status: null, message: timedOut ? TIMED_OUT : UNAVAILABLE };
+}
+/** The overview view: the connections per toolkit, and the matching tools once a filter is set. */
+export async function readOverview(client, query, signal) {
+    const params = { view: 'overview', ...query };
+    try {
+        const { data, error, response } = await client.GET(TOOLS_PATH, {
+            params: { query: params },
+            signal,
+        });
+        if (!response.ok)
+            return failureOf(response.status, error, 'GET');
+        const raw = isRow(data) ? data.data : undefined;
+        const overview = parseOverview(raw);
+        if (!overview) {
+            return {
+                ok: false,
+                status: response.status,
+                message: 'This platform does not offer the integrations overview yet.',
+            };
+        }
+        return { ok: true, overview, raw };
+    }
+    catch (error) {
+        return transportFailure(error, 'GET');
+    }
+}

package/dist/integrations/render.js

@@ -0,0 +1,52 @@
+/**
+ * `kosuke integrations list` as text: a block per toolkit, with its connections
+ * and tool counts, then the matching tools when a filter is set. A cut is never
+ * silent: the server's note is printed whenever it sent one.
+ */
+const plural = (count, noun) => `${count} ${noun}${count === 1 ? '' : 's'}`;
+function connectionLine(connection) {
+    const identity = connection.accountIdentity ?? 'account unknown';
+    const id = connection.id ? `, id ${connection.id}` : '';
+    return `${connection.alias}: ${connection.scope}, "${connection.label}", ${identity}${id}`;
+}
+function toolLine(tool, width) {
+    const access = (tool.access === 'read' ? '[read-only]' : '[writes]').padEnd(11);
+    const accounts = tool.aliases.length > 0 ? `  [account: ${tool.aliases.join(', ')}]` : '';
+    return `${tool.name.padEnd(width)}  ${access}  ${tool.description}${accounts}`.trimEnd();
+}
+export function renderOverview(overview, filtered) {
+    const { toolkits, tools, note } = overview;
+    if (toolkits.length === 0 && overview.connectionTotal === 0) {
+        return filtered ? 'No connected tool matches.\n' : 'No integrations are connected.\n';
+    }
+    if (filtered && tools?.length === 0)
+        return 'No connected tool matches.\n';
+    const width = Math.max(0, ...(tools ?? []).map((tool) => tool.name.length));
+    const blocks = toolkits.map((toolkit) => {
+        const lines = [
+            `${toolkit.name} (${toolkit.toolkit}): ${toolkit.read} read, ${toolkit.write} write tools`,
+            ...toolkit.connections.map((connection) => `  ${connectionLine(connection)}`),
+        ];
+        const own = (tools ?? []).filter((tool) => tool.toolkit === toolkit.toolkit);
+        if (own.length > 0) {
+            lines.push('  tools:', ...own.map((tool) => `    ${toolLine(tool, width)}`));
+        }
+        return lines.join('\n');
+    });
+    const out = [blocks.join('\n\n')];
+    if (tools) {
+        out.push(`${tools.length} of ${plural(overview.toolTotal ?? tools.length, 'tool')} shown.`);
+    }
+    else {
+        out.push(`${plural(overview.connectionTotal, 'connection')}. ` +
+            "`kosuke integrations list --toolkit <slug>` shows a toolkit's tools; " +
+            "`kosuke integrations describe <tool>` prints one tool's input schema.");
+    }
+    if (note)
+        out.push(note);
+    return `${out.join('\n\n')}\n`;
+}
+/** One connection per line, for a refusal that asks the caller to pick one. */
+export function choiceLines(choices) {
+    return choices.map((choice) => `  ${connectionLine(choice)}`).join('\n');
+}

package/dist/program.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import { attachAgentCommands } from './commands/agent.js';
 import { attachAuthCommands } from './commands/auth.js';
+import { attachIntegrationsCommands } from './commands/integrations.js';
 import { attachWatchCommand } from './commands/watch.js';
 import { operations } from './generated/commands/index.js';
 import { attachOperation } from './runtime/attach.js';
@@ -8,8 +9,8 @@ import { isCronToken, isLeadToken, isOrchestratorToken, isSandboxAgentToken, } f
 import { createRuntime, ExitSignal } from './runtime/runtime.js';
 import { version } from './runtime/version.js';
 /**
- * The command tree: `auth`, `agent` and `sessions watch` by hand, everything else
- * from the generated descriptors. Global flags are read before any subcommand runs, so the
+ * The command tree: `auth`, `agent`, `integrations list|describe|call` and `sessions watch` by
+ * hand, everything else from the generated descriptors. Global flags are read before any subcommand runs, so the
  * runtime the subcommands share is built once, from them.
  */
 export function createProgram(options = {}) {
@@ -55,6 +56,11 @@ export function createProgram(options = {}) {
     // member's own key and their Lead may mark Activity seen, so the others
     // read it with `--peek`.
     attachAgentCommands(program, lazy, options.agent);
+    // Beside the generated `integrations tools` and `execute`, which stay raw passthroughs. The
+    // orchestrator token reaches neither: Slack triage has no integration tools.
+    if (narrowedTo !== 'orchestratorToken') {
+        attachIntegrationsCommands(program, lazy, options.integrations);
+    }
     // The job stream admits a member's API key only; it closes 4401 on every narrower token.
     if (narrowedTo === null)
         attachWatchCommand(program, lazy, options.watch);

package/dist/runtime/client.js

@@ -99,6 +99,57 @@ function withTransportRetry(fetchImpl) {
         }
     };
 }
+/** The most of one integration answer the CLI reads; its listings are bounded well below it. */
+const MAX_INTEGRATION_RESPONSE_BYTES = 512 * 1024;
+const INTEGRATIONS_PREFIX = '/api/agent-integrations/';
+/** An integration answer past the cap; a call that got one may still have run. */
+export class ResponseTooLarge extends Error {
+    constructor() {
+        super('Integration response was too large');
+        this.name = 'ResponseTooLarge';
+    }
+}
+/**
+ * Caps what an integration route can make the CLI buffer, error bodies included. The body is
+ * counted as it streams, so nothing past the cap is held or parsed. Other routes are untouched.
+ */
+function withIntegrationCap(fetchImpl) {
+    return async (...args) => {
+        const response = await fetchImpl(...args);
+        const [input] = args;
+        try {
+            const href = input instanceof Request ? input.url : String(input);
+            if (!new URL(href, 'http://localhost').pathname.startsWith(INTEGRATIONS_PREFIX)) {
+                return response;
+            }
+        }
+        catch {
+            return response;
+        }
+        if (!response.body)
+            return response;
+        const declared = Number(response.headers.get('content-length'));
+        if (Number.isFinite(declared) && declared > MAX_INTEGRATION_RESPONSE_BYTES) {
+            await response.body.cancel().catch(() => undefined);
+            throw new ResponseTooLarge();
+        }
+        let total = 0;
+        const counted = response.body.pipeThrough(new TransformStream({
+            transform(chunk, controller) {
+                total += chunk.byteLength;
+                if (total > MAX_INTEGRATION_RESPONSE_BYTES)
+                    controller.error(new ResponseTooLarge());
+                else
+                    controller.enqueue(chunk);
+            },
+        }));
+        return new Response(counted, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        });
+    };
+}
 export function createApiClient({ apiUrl, apiKey, fetch }) {
     return createClient({
         baseUrl: apiUrl,
@@ -106,6 +157,6 @@ export function createApiClient({ apiUrl, apiKey, fetch }) {
             ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
             'User-Agent': `@kosuke-ai/cli/${version}`,
         },
-        fetch: withTransportRetry(fetch ?? globalThis.fetch),
+        fetch: withIntegrationCap(withTransportRetry(fetch ?? globalThis.fetch)),
     });
 }

package/dist/runtime/credentials.js

@@ -37,6 +37,15 @@ const LEAD_TOKEN_PREFIX = 'kosuke_lead_';
 export function isLeadToken(token) {
     return token?.startsWith(LEAD_TOKEN_PREFIX) ?? false;
 }
+/**
+ * A credential that decides its own workspace: a sandbox, cron or Lead token.
+ * The orchestrator token is left out because it reaches no integration tools.
+ */
+export function isTurnToken(token) {
+    return (isSandboxAgentToken(token ?? undefined) ||
+        isCronToken(token ?? undefined) ||
+        isLeadToken(token ?? undefined));
+}
 export function resolveCredentials(flags, env = process.env) {
     const stored = readCredentials(env);
     const apiKey = flags.apiKey

package/openapi.json

@@ -141,6 +141,224 @@
         }
       }
     },
+    "/api/agent-integrations/execute": {
+      "post": {
+        "operationId": "integrationsExecute",
+        "summary": "Run one integration tool. An agent runs it for its own workspace, or on the member’s personal connection when that member started the turn. With an API key, name a workspace you belong to: the call runs only on your own personal connections, and one on a workspace connection is refused. The answer names the connection it ran on, or lists the connections to choose from when the call needs one. A tool failure answers 200 with isError true. A Connector Token or a browser session is refused.",
+        "tags": ["integrations"],
+        "x-kosuke-command": ["integrations", "execute"],
+        "x-kosuke-sandbox-token": true,
+        "x-kosuke-cron-token": true,
+        "x-kosuke-lead-token": true,
+        "parameters": [
+          {
+            "name": "workspace",
+            "in": "query",
+            "required": false,
+            "description": "The workspace the call is made in. Required with an API key, which is refused with 403 when you are not a member of it. An agent credential reaches its own workspace and refuses another.",
+            "schema": {
+              "description": "The workspace the call is made in. Required with an API key, which is refused with 403 when you are not a member of it. An agent credential reaches its own workspace and refuses another.",
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 100
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "name": {
+                    "type": "string",
+                    "minLength": 1,
+                    "maxLength": 80,
+                    "description": "The tool to run, as the tools list names it."
+                  },
+                  "arguments": {
+                    "type": "object",
+                    "propertyNames": {
+                      "type": "string"
+                    },
+                    "additionalProperties": {},
+                    "description": "The tool's arguments, as its input schema describes them."
+                  },
+                  "account": {
+                    "description": "The connection to run on: its short id, its alias such as notion-personal, or scope:label. Needed when several can run the tool.",
+                    "type": "string",
+                    "minLength": 1,
+                    "maxLength": 100
+                  }
+                },
+                "required": ["name", "arguments"],
+                "additionalProperties": false
+              }
+            }
+          }
+        },
+        "responses": {
+          "2XX": {
+            "description": "Success envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiSuccess"
+                }
+              }
+            }
+          },
+          "4XX": {
+            "description": "Error envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          },
+          "5XX": {
+            "description": "Error envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/agent-integrations/tools": {
+      "get": {
+        "operationId": "integrationsTools",
+        "summary": "List the integration tools you can run now, with the connections that run them. An agent reads its own workspace. With an API key, name a workspace you belong to: it shows that workspace’s connections and your own personal ones. A Connector Token or a browser session is refused.",
+        "tags": ["integrations"],
+        "x-kosuke-command": ["integrations", "tools"],
+        "x-kosuke-sandbox-token": true,
+        "x-kosuke-cron-token": true,
+        "x-kosuke-lead-token": true,
+        "parameters": [
+          {
+            "name": "workspace",
+            "in": "query",
+            "required": false,
+            "description": "The workspace to list for. Required with an API key, which is refused with 403 when you are not a member of it. An agent credential reaches its own workspace and refuses another.",
+            "schema": {
+              "description": "The workspace to list for. Required with an API key, which is refused with 403 when you are not a member of it. An agent credential reaches its own workspace and refuses another.",
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 100
+            }
+          },
+          {
+            "name": "view",
+            "in": "query",
+            "required": false,
+            "description": "overview: the connections per toolkit with tool counts, and the matching tools once toolkit or search is set. summary: tool names and short descriptions, cut at 300. Without it, full definitions cut at a size budget, which is what older clients read.",
+            "schema": {
+              "description": "overview: the connections per toolkit with tool counts, and the matching tools once toolkit or search is set. summary: tool names and short descriptions, cut at 300. Without it, full definitions cut at a size budget, which is what older clients read.",
+              "type": "string",
+              "enum": ["summary", "overview"]
+            }
+          },
+          {
+            "name": "toolkit",
+            "in": "query",
+            "required": false,
+            "description": "Only this toolkit, by slug, such as gmail.",
+            "schema": {
+              "description": "Only this toolkit, by slug, such as gmail.",
+              "type": "string",
+              "pattern": "^[a-z0-9_]{1,64}$"
+            }
+          },
+          {
+            "name": "search",
+            "in": "query",
+            "required": false,
+            "description": "Only tools whose name, description or toolkit contains this text, in any case.",
+            "schema": {
+              "description": "Only tools whose name, description or toolkit contains this text, in any case.",
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 100
+            }
+          },
+          {
+            "name": "name",
+            "in": "query",
+            "required": false,
+            "description": "One tool by exact name, with its full input schema. 404 when you are not offered it.",
+            "schema": {
+              "description": "One tool by exact name, with its full input schema. 404 when you are not offered it.",
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 80
+            }
+          },
+          {
+            "name": "account",
+            "in": "query",
+            "required": false,
+            "description": "Only one connection: its short id, its alias such as notion-personal, or scope:label. Needed for a name that several connections can run.",
+            "schema": {
+              "description": "Only one connection: its short id, its alias such as notion-personal, or scope:label. Needed for a name that several connections can run.",
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 100
+            }
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "required": false,
+            "description": "With view overview, how many tools to list when toolkit or search is set. 40 by default.",
+            "schema": {
+              "description": "With view overview, how many tools to list when toolkit or search is set. 40 by default.",
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 100
+            }
+          }
+        ],
+        "responses": {
+          "2XX": {
+            "description": "Success envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiSuccess"
+                }
+              }
+            }
+          },
+          "4XX": {
+            "description": "Error envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          },
+          "5XX": {
+            "description": "Error envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/auth/github/repositories": {
       "get": {
         "operationId": "githubRepositories",
@@ -6049,6 +6267,10 @@
                     "type": "string",
                     "minLength": 1
                   },
+                  "auto": {
+                    "description": "True starts the session on Auto: Kosuke picks the Model and Provider of each Turn. False keeps it off. Absent follows your Default Model.",
+                    "type": "boolean"
+                  },
                   "status": {
                     "type": "string",
                     "const": "backlog"
@@ -6092,6 +6314,10 @@
                     "type": "string",
                     "minLength": 1
                   },
+                  "auto": {
+                    "description": "True starts the session on Auto: Kosuke picks the Model and Provider of each Turn. False keeps it off. Absent follows your Default Model.",
+                    "type": "boolean"
+                  },
                   "status": {
                     "type": "string",
                     "const": "backlog"
@@ -6221,7 +6447,7 @@
       },
       "put": {
         "operationId": "sessionsUpdate",
-        "summary": "Change title, status, model, Assignee or priority. Which changes are legal depends on the current status; the handler decides.",
+        "summary": "Change title, status, model, Auto, Assignee or priority. Which changes are legal depends on the current status; the handler decides.",
         "tags": ["sessions"],
         "x-kosuke-command": ["sessions", "update"],
         "x-kosuke-sandbox-token": true,
@@ -6282,6 +6508,10 @@
                     "type": "string",
                     "minLength": 1
                   },
+                  "auto": {
+                    "description": "True puts the session on Auto, from its next Turn. False takes it off; send it with model when choosing a Model. Absent leaves it as it is.",
+                    "type": "boolean"
+                  },
                   "ownerId": {
                     "anyOf": [
                       {
@@ -7170,6 +7400,10 @@
                     "type": "string",
                     "minLength": 1
                   },
+                  "auto": {
+                    "description": "True puts the session on Auto from this Turn: Kosuke picks its Model and Provider. False takes it off, with model or the session's own. Absent keeps the session as it is.",
+                    "type": "boolean"
+                  },
                   "previewContext": {
                     "type": "object",
                     "properties": {
@@ -7273,6 +7507,11 @@
                     "type": "string",
                     "minLength": 1
                   },
+                  "auto": {
+                    "description": "As the JSON body's auto.",
+                    "type": "string",
+                    "enum": ["true", "false"]
+                  },
                   "previewContext": {
                     "description": "JSON-encoded { frontendName, path }.",
                     "type": "string"
@@ -9001,6 +9240,11 @@
                     "type": "string",
                     "minLength": 1
                   },
+                  "auto": {
+                    "description": "true puts the ticket on Auto: Kosuke picks the Model and Provider of each Turn. false takes it off; send it with model when choosing a Model. Absent leaves it as it is.",
+                    "type": "string",
+                    "enum": ["true", "false"]
+                  },
                   "ownerId": {
                     "description": "A member id to assign, or an empty string to unassign.",
                     "type": "string"
@@ -13799,7 +14043,7 @@
     "/api/user/subscriptions": {
       "get": {
         "operationId": "userSubscriptionsGet",
-        "summary": "Read your Claude, Codex, GLM Coding Plan, Kimi Code and DeepSeek API subscriptions and your default model. Per provider: the login in use (connected, needsReauth, accountEmail, and maskedApiKey for a pasted key) and every login in the order it is used (logins).",
+        "summary": "Read your Claude, Codex, GLM Coding Plan, Kimi Code and DeepSeek API subscriptions and your default model, with defaultAuto when it is Auto. Per provider: the login in use (connected, needsReauth, accountEmail, and maskedApiKey for a pasted key) and every login in the order it is used (logins).",
         "tags": ["user"],
         "x-kosuke-command": ["user", "subscriptions", "get"],
         "x-kosuke-sandbox-token": true,
@@ -13841,7 +14085,7 @@
       },
       "patch": {
         "operationId": "userSubscriptionsSetDefaultModel",
-        "summary": "Save the model new chat sessions start on, as an encoded id such as anthropic:sonnet__medium, or null to let Kosuke choose. Answers 204.",
+        "summary": "Save the model new chat sessions start on, as an encoded id such as anthropic:sonnet__medium, or null to let Kosuke choose, or defaultAuto: true to start them on Auto. Answers 204.",
         "tags": ["user"],
         "x-kosuke-command": ["user", "subscriptions", "set-default-model"],
         "requestBody": {
@@ -13853,9 +14097,12 @@
                 "properties": {
                   "defaultModel": {
                     "type": ["string", "null"]
+                  },
+                  "defaultAuto": {
+                    "description": "True makes Auto your Default Model; defaultModel stays as it is unless sent.",
+                    "type": "boolean"
                   }
-                },
-                "required": ["defaultModel"]
+                }
               }
             }
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kosuke-ai/cli",
-  "version": "6.7.0",
+  "version": "6.9.0",
   "description": "Kosuke platform CLI. The client customers install to drive app.kosuke.ai from their own machine.",
   "license": "MIT",
   "repository": {