@kosuke-ai/kosuke 1.0.14 → 1.0.16

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.0.16
+
+- New `kosuke sensei fyi move` command: Sensei moves a conversation out of the FYI digest so it gets a drafted reply in its own thread.
+
+## 1.0.15
+
+- `kosuke integrations call --file <argument>=<path>` uploads a local file for a tool's file argument, such as a YouTube video or a Gmail attachment.
+
 ## 1.0.14
 
 - `kosuke devices list` says whether another session or Sensei already uses each device, and `kosuke sensei device-requests list` says it for each pending request.

package/README.md

@@ -165,6 +165,7 @@ kosuke integrations list --workspace <id>                    # a block per toolk
 kosuke integrations list --workspace <id> --toolkit gmail    # that toolkit's tools
 kosuke integrations tools get <tool> --workspace <id>         # one tool's input schema
 kosuke integrations call <tool> --workspace <id> --account notion-personal --args '{"query":"roadmap"}'
+kosuke integrations call youtube_upload_video --workspace <id> --args-file video.json --file videoFilePath=./clip.mp4
 ```
 
 `list` with no filter prints each toolkit's connections (alias, scope, label,
@@ -174,7 +175,10 @@ and how to narrow it. `--account` takes a connection's alias such as
 `notion-personal`, its short id or `scope:label`; case, curly quotes and extra
 spaces do not matter, and it is needed when several connections can run a tool.
 `call` prints the tool's text on stdout and the connection it ran on on stderr,
-and exits 1 when the tool reports an error.
+and exits 1 when the tool reports an error. A tool's file argument takes a file
+reference: `--file <argument>=<path>` uploads the local file and fills it in,
+once per file, and a file inside a list or object names its path, such as
+`attachment.0`. The file goes straight to storage, up to 5 GiB.
 
 With an API key, `--workspace` is required (you must belong to it), and `call`
 runs only your own personal connections. Inside an agent's turn the credential

package/dist/commands/hand-written.js

@@ -55,7 +55,7 @@ export const HAND_WRITTEN = {
     integrationsCall: {
         command: ['integrations', 'call'],
         positionals: ['name', 'stdin'],
-        flags: ['--account', '--args', '--args-file', '--workspace'],
+        flags: ['--account', '--args', '--args-file', '--file', '--workspace'],
         agents: 'all',
         workspace: true,
     },

package/dist/commands/integrations.js

@@ -4,6 +4,7 @@ import { leafAt } from '../runtime/attach.js';
 import { HAND_WRITTEN } from './hand-written.js';
 import { isTurnToken } from '../runtime/credentials.js';
 import { connectionOf, failureOf, isRow, oneLine, readOverview, rowsOf, TOOLS_PATH, transportFailure, } from '../integrations/api.js';
+import { FILE_UPLOAD_PATH, fileSize, MAX_FILE_BYTES, md5Of, mimetypeOf, parseFileArgument, putFile, setAt, uploadName, } from '../integrations/file-upload.js';
 import { choiceLines, renderOverview } from '../integrations/render.js';
 /**
  * `kosuke integrations list|call` and `kosuke integrations tools get`: the connected tools,
@@ -24,6 +25,8 @@ const READ_TIMEOUT_MS = 30_000;
  * 60 s budget, and wait no longer than their answer takes.
  */
 const CALL_TIMEOUT_MS = 330_000;
+/** One file's PUT to storage; the storage URL lets an upload start for an hour. */
+const UPLOAD_TIMEOUT_MS = 60 * 60_000;
 const EXIT_FAILED = 1;
 const EXIT_USAGE = 2;
 const TOOLKIT_PATTERN = /^[a-z0-9_]{1,64}$/;
@@ -57,6 +60,13 @@ function accountText(raw) {
     }
     return raw;
 }
+function fileArguments(raw, previous = []) {
+    const parsed = parseFileArgument(raw);
+    if (!parsed) {
+        throw new InvalidArgumentError('Expected <argument>=<path>, such as videoFilePath=./clip.mp4 or attachment.0=./report.pdf.');
+    }
+    return [...previous, parsed];
+}
 function limitNumber(raw) {
     if (!/^\d+$/.test(raw) || Number(raw) < 1 || Number(raw) > 100) {
         throw new InvalidArgumentError('Expected a whole number from 1 to 100.');
@@ -111,10 +121,36 @@ function failureText(text, choices, tool, given) {
     }
     return body.message;
 }
+/** The reserved upload a successful file-upload answer carries in its text. */
+function uploadOf(answer) {
+    const block = rowsOf(answer.content)[0];
+    if (!block || typeof block.text !== 'string')
+        return null;
+    let body;
+    try {
+        body = JSON.parse(block.text);
+    }
+    catch {
+        return null;
+    }
+    if (!isRow(body) || typeof body.file !== 'string' || !isRow(body.upload))
+        return null;
+    const { url, headers } = body.upload;
+    if (typeof url !== 'string' || !url.startsWith('https://'))
+        return null;
+    const kept = {};
+    if (isRow(headers)) {
+        for (const [key, value] of Object.entries(headers)) {
+            if (typeof value === 'string')
+                kept[key] = value;
+        }
+    }
+    return { file: body.file, url, headers: kept };
+}
 export function attachIntegrationsCommands(root, runtime, deps = {}) {
     const { stdout = (text) => process.stdout.write(text), stderr = (text) => process.stderr.write(text), exit = (code) => {
         process.exitCode = code;
-    }, readStdin = readAllStdin, readFile: readText = (path) => readFile(path, 'utf8'), readTimeoutMs = READ_TIMEOUT_MS, callTimeoutMs = CALL_TIMEOUT_MS, } = deps;
+    }, readStdin = readAllStdin, readFile: readText = (path) => readFile(path, 'utf8'), readTimeoutMs = READ_TIMEOUT_MS, callTimeoutMs = CALL_TIMEOUT_MS, uploadFetch = (input, init) => globalThis.fetch(input, init), } = deps;
     const fail = (failure, code = EXIT_FAILED) => {
         stderr(`${typeof failure === 'string' ? failure : failure.message}\n`);
         exit(code);
@@ -214,6 +250,8 @@ export function attachIntegrationsCommands(root, runtime, deps = {}) {
         .option('--account <account>', 'The connection to run on: an alias, id or scope:label. Needed when several can run the tool.', accountText)
         .option('--args <json>', 'The tool arguments, a JSON object. Default {}.')
         .option('--args-file <path>', 'Read the arguments from a file, or - for stdin.')
+        .option('--file <argument=path>', 'Upload a local file for a file argument and pass its reference there. Repeat it for ' +
+        'several files; one inside a list or object names its path, such as attachment.0.', fileArguments)
         .option('--workspace <id>', WORKSPACE_HELP)
         .addHelpText('after', '\nWith an API key, a call runs only on your own personal connections; one on a workspace\n' +
         "connection is refused (an agent's turn in the workspace can run it).\n" +
@@ -224,6 +262,14 @@ export function attachIntegrationsCommands(root, runtime, deps = {}) {
         const toolArguments = await readArguments(flags, dash);
         const client = runtime.client({ answerTimeoutMs: callTimeoutMs });
         const workspace = workspaceFor(runtime, flags.workspace);
+        for (const file of flags.file ?? []) {
+            const placed = await uploadFile(client, name, file, flags.account, workspace);
+            if (placed === null)
+                return;
+            if (!setAt(toolArguments, file.at, placed)) {
+                throw new UsageError(`--file ${file.at.join('.')} does not fit the arguments: something else is already there.`);
+            }
+        }
         let data;
         try {
             const result = await client.POST(EXECUTE_PATH, {
@@ -245,6 +291,72 @@ export function attachIntegrationsCommands(root, runtime, deps = {}) {
         }
         report(name, flags.account, data);
     }));
+    /**
+     * Reserves one file's upload, sends the file to storage and answers its reference, or reports
+     * the failure and answers null. Nothing is called yet, so a failure here changes nothing.
+     */
+    async function uploadFile(client, name, file, account, workspace) {
+        const size = await fileSize(file.path);
+        if (size === null)
+            throw new UsageError(`--file: ${file.path} is not a file this can read.`);
+        if (size === 0)
+            throw new UsageError(`--file: ${file.path} is empty.`);
+        if (size > MAX_FILE_BYTES)
+            throw new UsageError(`--file: ${file.path} is larger than 5 GiB.`);
+        const filename = uploadName(file.path);
+        if (filename === null) {
+            throw new UsageError(`--file: rename ${file.path} to a plain name of up to 255 characters.`);
+        }
+        const mimetype = mimetypeOf(filename);
+        let md5;
+        try {
+            md5 = await md5Of(file.path);
+        }
+        catch {
+            throw new UsageError(`--file: could not read ${file.path}.`);
+        }
+        let data;
+        try {
+            const result = await client.POST(FILE_UPLOAD_PATH, {
+                params: { query: workspace ? { workspace } : {} },
+                body: { name, filename, mimetype, md5, ...(account ? { account } : {}) },
+                signal: AbortSignal.timeout(readTimeoutMs),
+            });
+            if (!result.response.ok) {
+                fail(failureOf(result.response.status, result.error, 'GET'));
+                return null;
+            }
+            data = isRow(result.data) ? result.data.data : undefined;
+        }
+        catch (error) {
+            // Reserving an upload changes nothing a retry could repeat, so it reads like a lookup.
+            fail(transportFailure(error, 'GET'));
+            return null;
+        }
+        const answer = isRow(data) ? data : {};
+        if (answer.isError === true) {
+            report(name, account, data);
+            return null;
+        }
+        const upload = uploadOf(answer);
+        if (!upload) {
+            fail('Integration tools returned an unexpected response.');
+            return null;
+        }
+        let status;
+        try {
+            status = await putFile(uploadFetch, upload, file.path, size, mimetype, AbortSignal.timeout(UPLOAD_TIMEOUT_MS));
+        }
+        catch {
+            fail(`Could not upload ${file.path}; the tool was not called. Try again.`);
+            return null;
+        }
+        if (status < 200 || status > 299) {
+            fail(`The upload of ${file.path} was refused (HTTP ${status}); the tool was not called.`);
+            return null;
+        }
+        return upload.file;
+    }
     /** Reads `--args`, `--args-file` or a lone `-`: one source at most, and a JSON object. */
     async function readArguments(flags, dash) {
         if (dash !== undefined && dash !== '-')