@notis_ai/cli 0.2.0-beta.35.1 → 0.2.0-beta.48.1

package/src/command-specs/tools.js

@@ -1,13 +1,14 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { accessSync, constants as fsConstants, createReadStream, existsSync, readFileSync, statSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { basename } from 'node:path';
 import { usageError } from '../runtime/errors.js';
 import {
+  fetchToolDiscovery,
   fetchToolkits,
   fetchToolSchema,
   nextIdempotencyKey,
   parseJson,
   parseMaybeJson,
-  normalizeToolkits,
-  resolveSearchToolkits,
   runToolCommand,
   validateArguments,
 } from './helpers.js';
@@ -42,6 +43,89 @@ const LONG_RUNNING_TOOL_NAMES = new Set([
   'notis-default-edit_image_gemini',
 ]);
 
+const EXTENSION_CONTENT_TYPES = new Map([
+  ['.pdf', 'application/pdf'],
+  ['.png', 'image/png'],
+  ['.jpg', 'image/jpeg'],
+  ['.jpeg', 'image/jpeg'],
+  ['.gif', 'image/gif'],
+  ['.webp', 'image/webp'],
+  ['.txt', 'text/plain'],
+  ['.csv', 'text/csv'],
+  ['.json', 'application/json'],
+  ['.md', 'text/markdown'],
+]);
+
+function guessContentType(filePath) {
+  const lower = filePath.toLowerCase();
+  const dotIndex = lower.lastIndexOf('.');
+  if (dotIndex === -1) return 'application/octet-stream';
+  return EXTENSION_CONTENT_TYPES.get(lower.slice(dotIndex)) || 'application/octet-stream';
+}
+
+async function hashFileSha256(localPath) {
+  const hash = createHash('sha256');
+  for await (const chunk of createReadStream(localPath)) {
+    hash.update(chunk);
+  }
+  return hash.digest('hex');
+}
+
+async function parseFileBindingSpec(spec, index) {
+  if (typeof spec !== 'string' || !spec.trim()) {
+    throw usageError('--file must be formatted as <argument-path>=<local-path>');
+  }
+
+  const equalsIndex = spec.indexOf('=');
+  if (equalsIndex <= 0 || equalsIndex === spec.length - 1) {
+    throw usageError('--file must be formatted as <argument-path>=<local-path>');
+  }
+
+  const argumentPath = spec.slice(0, equalsIndex).trim();
+  const localPath = spec.slice(equalsIndex + 1).trim();
+  if (!argumentPath) {
+    throw usageError('--file argument path is required');
+  }
+  if (!localPath) {
+    throw usageError('--file local path is required');
+  }
+  if (!existsSync(localPath)) {
+    throw usageError(`File not found: ${localPath}`);
+  }
+
+  let stats;
+  try {
+    stats = statSync(localPath);
+    accessSync(localPath, fsConstants.R_OK);
+  } catch {
+    throw usageError(`File is not readable: ${localPath}`);
+  }
+  if (!stats.isFile()) {
+    throw usageError(`File is not a regular file: ${localPath}`);
+  }
+
+  const sha256 = await hashFileSha256(localPath);
+  const fileBasename = basename(localPath);
+  const fieldName = `file_${index}`;
+
+  return {
+    argument_path: argumentPath,
+    field_name: fieldName,
+    basename: fileBasename,
+    size: stats.size,
+    sha256,
+    contentType: guessContentType(fileBasename),
+    localPath,
+  };
+}
+
+async function parseFileBindings(rawFileOptions) {
+  const values = Array.isArray(rawFileOptions)
+    ? rawFileOptions
+    : (rawFileOptions ? [rawFileOptions] : []);
+  return Promise.all(values.map((value, index) => parseFileBindingSpec(value, index)));
+}
+
 function ensureLongRunningToolTimeout(ctx, toolNames) {
   const names = Array.isArray(toolNames) ? toolNames : [toolNames];
   if (!names.some((name) => LONG_RUNNING_TOOL_NAMES.has(name))) {
@@ -57,27 +141,55 @@ async function toolsToolkitsHandler(ctx) {
     data: { toolkits },
     humanSummary: `Found ${toolkits.length} toolkits`,
     hints: [
-      { command: 'notis tools search <query>', reason: 'Search for tools in these toolkits' },
+      { command: 'notis tools search <query>', reason: 'Search canonical tools and schemas' },
     ],
-    renderHuman: () => toolkits.map((entry) => `${entry.id}  ${entry.description}`).join('\n'),
+    renderHuman: () =>
+      toolkits
+        .map((entry) => {
+          const status = entry.has_active_connection ? 'connected' : 'needs auth';
+          return `${entry.id}  ${status}  ${entry.description}`;
+        })
+        .join('\n'),
   });
 }
 
+function discoveryToolRows(payload) {
+  const schemas = payload.tool_schemas || {};
+  const statuses = new Map(
+    (payload.toolkit_connection_statuses || [])
+      .filter((entry) => entry && typeof entry.toolkit === 'string')
+      .map((entry) => [entry.toolkit, entry])
+  );
+  const seen = new Set();
+  const rows = [];
+  for (const result of payload.results || []) {
+    for (const name of [...(result.primary_tool_slugs || []), ...(result.related_tool_slugs || [])]) {
+      if (!name || seen.has(name)) continue;
+      seen.add(name);
+      const schema = schemas[name] || {};
+      const toolkit = schema.toolkit || name.split('-').slice(0, -1).join('-');
+      const status = statuses.get(toolkit);
+      rows.push({
+        name,
+        toolkit,
+        description: schema.description || '',
+        schema_available: Boolean(schemas[name]),
+        connection_status: status
+          ? (status.has_active_connection ? 'connected' : 'needs auth')
+          : 'unknown',
+      });
+    }
+  }
+  return rows;
+}
+
 async function toolsSearchHandler(ctx) {
-  const toolkits = await resolveSearchToolkits(ctx.runtime, ctx.options.toolkits);
-  const result = await runToolCommand({
-    runtime: ctx.runtime,
-    toolName: 'notis_find_tools',
-    arguments_: {
-      query: ctx.args.query || undefined,
-      toolkits,
-    },
-  });
-  const tools = result.payload.tools || [];
+  const payload = await fetchToolDiscovery(ctx.runtime, ctx.args.query || 'Find tools', ctx.options.knownFields || '');
+  const tools = discoveryToolRows(payload);
   const firstTool = tools[0];
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
-    data: { toolkits, tools },
+    data: payload,
     humanSummary: `Found ${tools.length} tools`,
     hints: firstTool
       ? [
@@ -87,31 +199,18 @@ async function toolsSearchHandler(ctx) {
       : [],
     renderHuman: () =>
       tools
-        .map((tool) => `${tool.name}\n  ${tool.toolkit_id || 'unknown toolkit'}\n  ${tool.description || 'No description'}\n`)
+        .map((tool) => `${tool.name}\n  toolkit: ${tool.toolkit || 'unknown'} (${tool.connection_status})\n  schema: ${tool.schema_available ? 'available' : 'missing'}\n  ${tool.description || 'No description'}\n`)
         .join('\n')
         .trim(),
   });
 }
 
 async function toolsDescribeHandler(ctx) {
-  const toolkits = await resolveSearchToolkits(ctx.runtime, ctx.options.toolkits);
-  const result = await runToolCommand({
-    runtime: ctx.runtime,
-    toolName: 'notis_find_tools',
-    arguments_: {
-      query: ctx.args.toolName,
-      toolkits,
-    },
-  });
-  const tools = result.payload.tools || [];
-  const match = tools.find((tool) => tool.name === ctx.args.toolName);
-  if (!match) {
-    throw usageError(`Tool ${ctx.args.toolName} was not found in the selected toolkits.`);
-  }
+  const match = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
 
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
-    data: { tool: match, toolkits },
+    data: { tool: match },
     humanSummary: `Described tool ${ctx.args.toolName}`,
     hints: [
       { command: `notis tools exec ${ctx.args.toolName} --dry-run --arguments '{}'`, reason: 'Validate arguments first' },
@@ -123,13 +222,13 @@ async function toolsDescribeHandler(ctx) {
 
 async function toolsExecHandler(ctx) {
   ensureLongRunningToolTimeout(ctx, ctx.args.toolName);
-  const toolkits = normalizeToolkits(ctx.options.toolkits);
+  const fileBindings = await parseFileBindings(ctx.options.file);
 
   if (ctx.options.getSchema) {
-    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName, ctx.options.toolkits);
+    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
     return ctx.output.emitSuccess({
       command: ctx.spec.command_path.join(' '),
-      data: { tool, toolkits },
+      data: { tool },
       humanSummary: `Schema for ${ctx.args.toolName}`,
       hints: [
         { command: `notis tools exec ${ctx.args.toolName} --dry-run --arguments '{}'`, reason: 'Validate arguments before executing' },
@@ -144,13 +243,16 @@ async function toolsExecHandler(ctx) {
     : parseMaybeJson(rawArguments, 'arguments') || {};
 
   if (ctx.options.dryRun) {
-    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName, ctx.options.toolkits);
+    if (fileBindings.length) {
+      throw usageError('--file is only supported when executing a tool, not with --dry-run');
+    }
+    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
     const errors = validateArguments(tool.parameters, args);
 
     if (errors.length) {
       return ctx.output.emitSuccess({
         command: ctx.spec.command_path.join(' '),
-        data: { valid: false, errors, tool: ctx.args.toolName, toolkits },
+        data: { valid: false, errors, tool: ctx.args.toolName },
         humanSummary: `Dry run failed: ${errors.length} validation error(s)`,
         hints: [
           { command: `notis tools exec ${ctx.args.toolName} --get-schema`, reason: 'Review the full parameter schema' },
@@ -161,7 +263,7 @@ async function toolsExecHandler(ctx) {
 
     return ctx.output.emitSuccess({
       command: ctx.spec.command_path.join(' '),
-      data: { valid: true, tool: ctx.args.toolName, arguments: args, toolkits },
+      data: { valid: true, tool: ctx.args.toolName, arguments: args },
       humanSummary: `Dry run passed for ${ctx.args.toolName}`,
       hints: [
         { command: `notis tools exec ${ctx.args.toolName} --arguments '${JSON.stringify(args)}'`, reason: 'Execute with these arguments' },
@@ -177,10 +279,10 @@ async function toolsExecHandler(ctx) {
     arguments_: {
       tool_name: ctx.args.toolName,
       arguments: args,
-      ...(toolkits.length ? { toolkits } : {}),
     },
     mutating: true,
     idempotencyKey,
+    fileBindings,
   });
 
   return ctx.output.emitSuccess({
@@ -193,6 +295,10 @@ async function toolsExecHandler(ctx) {
 }
 
 async function toolsExecParallelHandler(ctx) {
+  const parallelFileBindings = await parseFileBindings(ctx.options.file);
+  if (parallelFileBindings.length) {
+    throw usageError('--file is supported by `notis tools exec` only; exec-parallel accepts JSON calls without file uploads.');
+  }
   const calls = parseMaybeJson(ctx.args.calls, 'calls');
   if (!Array.isArray(calls) || !calls.length) {
     throw usageError('calls must be a non-empty JSON array of {tool_name, arguments} objects');
@@ -275,15 +381,15 @@ async function toolsLinkHandler(ctx) {
 export const toolsCommandSpecs = [
   {
     command_path: ['tools', 'toolkits'],
-    summary: 'List toolkit namespaces available to the active user.',
-    when_to_use: 'Use this before searching or executing generic tools.',
+    summary: 'List toolkit namespaces and connection statuses available to the active user.',
+    when_to_use: 'Use this to inspect connection state before searching or executing generic tools.',
     args_schema: { arguments: [], options: [] },
     examples: ['notis tools toolkits', 'notis tools toolkits --json'],
-    output_schema: 'Returns available toolkit namespaces.',
+    output_schema: 'Returns toolkit_connection_statuses from notis_find_tools, rendered as toolkit rows.',
     mutates: false,
     idempotent: true,
     related_commands: ['notis tools search <query>', 'notis tools describe <tool-name>'],
-    backend_call: { type: 'tool', name: 'notis_find_toolkits' },
+    backend_call: { type: 'tool', name: 'notis_find_tools' },
     handler: toolsToolkitsHandler,
   },
   {
@@ -292,10 +398,10 @@ export const toolsCommandSpecs = [
     when_to_use: 'Use this when you need a generic capability that does not have a first-class CLI command.',
     args_schema: {
       arguments: [{ token: '<query>', description: 'Natural language description of the tool you need.' }],
-      options: [{ flags: '--toolkits <csv-or-json>', description: 'Optional subset of toolkit ids to search.' }],
+      options: [{ flags: '--known-fields <text>', key: 'knownFields', description: 'Optional known field hints, such as channel_name:general or user_email:a@example.com.' }],
     },
-    examples: ['notis tools search "send an email"', 'notis tools search "update framer page" --toolkits mcp-framer'],
-    output_schema: 'Returns tool matches with descriptions and parameter schemas.',
+    examples: ['notis tools search "send an email"', 'notis tools search "post on LinkedIn" --known-fields "platform:linkedin"'],
+    output_schema: 'Returns the full notis_find_tools response. Human output renders canonical names, connection status, and schema availability.',
     mutates: false,
     idempotent: true,
     related_commands: ['notis tools toolkits', 'notis tools exec <tool-name>'],
@@ -308,9 +414,9 @@ export const toolsCommandSpecs = [
     when_to_use: 'Use this when you know the tool name and want its parameter schema before execution.',
     args_schema: {
       arguments: [{ token: '<tool-name>', description: 'Exact tool name to locate and describe.' }],
-      options: [{ flags: '--toolkits <csv-or-json>', description: 'Optional subset of toolkit ids to search.' }],
+      options: [],
     },
-    examples: ['notis tools describe composio-gmail-default-send_email', 'notis tools describe notis-default-query --toolkits notis-default'],
+    examples: ['notis tools describe composio-gmail-default-send_email', 'notis tools describe notis-default-query'],
     output_schema: 'Returns one tool descriptor with name, description, and parameters.',
     mutates: false,
     idempotent: true,
@@ -326,9 +432,9 @@ export const toolsCommandSpecs = [
       arguments: [{ token: '<tool-name>', description: 'Tool name returned by `notis tools search`.' }],
       options: [
         { flags: '--arguments <json>', description: 'JSON object, @file path, or - for stdin.' },
+        { flags: '--file <argument-path=local-path>', description: 'Upload a local file into a file-uploadable tool argument. Repeatable.', collect: true },
         { flags: '--get-schema', description: 'Display the tool parameter schema without executing.' },
         { flags: '--dry-run', description: 'Validate arguments against the tool schema without executing.' },
-        { flags: '--toolkits <csv-or-json>', description: 'Optional toolkit namespace(s) to use when resolving the tool.' },
       ],
     },
     examples: [
@@ -338,6 +444,7 @@ export const toolsCommandSpecs = [
       'notis tools exec notis-default-query --dry-run --arguments \'{"database_slug":"tasks","query":{}}\'',
       'notis tools exec notis-default-query --arguments @query.json',
       'notis tools exec notis-default-query --arguments - < query.json',
+      'notis tools exec composio-dropbox-default-upload_file --arguments \'{"path":"/target/in/dropbox.pdf"}\' --file content=./Invoice.pdf',
     ],
     output_schema: 'Returns the raw tool execution payload.',
     mutates: true,
@@ -354,7 +461,9 @@ export const toolsCommandSpecs = [
       arguments: [
         { token: '<calls>', description: 'JSON array of {tool_name, arguments} objects.' },
       ],
-      options: [],
+      options: [
+        { flags: '--file <argument-path=local-path>', description: 'Unsupported for exec-parallel; use tools exec for file uploads.', collect: true },
+      ],
     },
     examples: [
       'notis tools exec-parallel \'[{"tool_name":"notis-default-query","arguments":{"database_slug":"tasks","query":{}}},{"tool_name":"notis-default-list_databases","arguments":{}}]\'',

package/src/runtime/app-dev-server.js

@@ -114,8 +114,8 @@ function reactVersionFromPeer(peerRange) {
 function resolveHarnessReactVersion(projectDir) {
   const candidates = [
     join(projectDir, 'node_modules', '@notis', 'sdk', 'package.json'),
-    join(REPO_ROOT, 'packages', 'notis-sdk', 'package.json'),
-    join(CLI_ROOT, 'template', 'packages', 'notis-sdk', 'package.json'),
+    join(REPO_ROOT, 'packages', 'sdk', 'package.json'),
+    join(CLI_ROOT, 'template', 'packages', 'sdk', 'package.json'),
   ];
   for (const candidate of candidates) {
     const pkg = readJsonFile(candidate);

package/src/runtime/app-platform.js

@@ -27,6 +27,7 @@ const MONOREPO_APPS_DIR = resolve(CLI_ROOT, '../..', 'apps');
 const DIST_DIR = join(CLI_ROOT, 'dist');
 const SCAFFOLD_CATALOG_FILE = join(DIST_DIR, 'scaffolds.json');
 const SCAFFOLD_SOURCE_DIR = join(DIST_DIR, 'scaffolds');
+const TEMPLATE_SDK_DIR = join(CLI_ROOT, 'template', 'packages', 'sdk');
 export const NOTIS_APP_CATEGORIES = [
   'Productivity',
   'Sales & Marketing',
@@ -787,6 +788,7 @@ export function scaffoldProject({ projectDir, appName, fromSlug = null }) {
   if (existsSync(pkgPath)) {
     const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
     pkg.name = appName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+    ensureScaffoldLocalSdk(projectDir, pkg);
     writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
   }
 
@@ -821,6 +823,32 @@ export function scaffoldProject({ projectDir, appName, fromSlug = null }) {
   return { projectDir };
 }
 
+function ensureScaffoldLocalSdk(projectDir, pkg) {
+  let shouldInstallLocalSdk = false;
+  for (const dependencyGroup of ['dependencies', 'devDependencies']) {
+    const dependencyValue = pkg[dependencyGroup]?.['@notis/sdk'];
+    if (typeof dependencyValue === 'string' && dependencyValue.startsWith('file:')) {
+      pkg[dependencyGroup]['@notis/sdk'] = 'file:./packages/sdk';
+      shouldInstallLocalSdk = true;
+    }
+  }
+
+  if (!shouldInstallLocalSdk) {
+    return;
+  }
+
+  const localSdkDir = join(projectDir, 'packages', 'sdk');
+  if (existsSync(join(localSdkDir, 'package.json'))) {
+    return;
+  }
+  if (!existsSync(join(TEMPLATE_SDK_DIR, 'package.json'))) {
+    throw usageError(`SDK template not found at ${TEMPLATE_SDK_DIR}. Ensure @notis_ai/cli is installed correctly.`);
+  }
+
+  mkdirSync(dirname(localSdkDir), { recursive: true });
+  cpSync(TEMPLATE_SDK_DIR, localSdkDir, { recursive: true, dereference: true });
+}
+
 function resolveScaffoldSourceDir(fromSlug) {
   const bundledDir = join(SCAFFOLD_SOURCE_DIR, fromSlug);
   if (existsSync(bundledDir)) {

package/src/runtime/transport.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
 import { CliError, EXIT_CODES } from './errors.js';
 import {
   DEFAULT_PROFILE,
@@ -8,31 +9,71 @@ import {
   saveConfig,
 } from './profiles.js';
 
-const META_TOOL_NAMES = new Set([
-  'notis_find_toolkits',
-  'notis_find_tools',
-  'notis_execute_tool',
-  'notis_find_additional_tools',
-]);
-
-function canonicalizeToolName(toolName) {
-  if (typeof toolName !== 'string' || !toolName.length) {
-    return toolName;
-  }
+function escapeMultipartHeaderValue(value) {
+  return String(value ?? '')
+    .replace(/"/g, '%22')
+    .replace(/\r/g, '%0D')
+    .replace(/\n/g, '%0A');
+}
 
-  if (META_TOOL_NAMES.has(toolName) || toolName.startsWith('notis-default-')) {
-    return toolName;
-  }
+function multipartTextPart(boundary, name, value) {
+  return [
+    `--${boundary}`,
+    `Content-Disposition: form-data; name="${escapeMultipartHeaderValue(name)}"`,
+    '',
+    value,
+    '',
+  ].join('\r\n');
+}
 
-  if (toolName.startsWith('notis_')) {
-    return `notis-default-${toolName.slice('notis_'.length)}`;
-  }
+function multipartFileHeader(boundary, binding) {
+  const filename = escapeMultipartHeaderValue(binding.basename || binding.field_name);
+  return [
+    `--${boundary}`,
+    `Content-Disposition: form-data; name="${escapeMultipartHeaderValue(binding.field_name)}"; filename="${filename}"`,
+    `Content-Type: ${binding.contentType || 'application/octet-stream'}`,
+    '',
+    '',
+  ].join('\r\n');
+}
 
-  if (toolName.includes('_notis_')) {
-    return `notis-default-${toolName.replace(/_notis_/g, '_')}`;
+async function* multipartFileBody(boundary, payload, bindingMetadata, fileBindings) {
+  yield Buffer.from(multipartTextPart(boundary, 'payload', JSON.stringify(payload)));
+  yield Buffer.from(multipartTextPart(boundary, 'file_bindings', JSON.stringify(bindingMetadata)));
+  for (const binding of fileBindings) {
+    yield Buffer.from(multipartFileHeader(boundary, binding));
+    for await (const chunk of createReadStream(binding.localPath)) {
+      yield chunk;
+    }
+    yield Buffer.from('\r\n');
   }
+  yield Buffer.from(`--${boundary}--\r\n`);
+}
 
-  return toolName;
+function createMultipartFileUpload(payload, bindingMetadata, fileBindings) {
+  const boundary = `----notis-cli-${randomUUID().replace(/-/g, '')}`;
+  const textParts = [
+    multipartTextPart(boundary, 'payload', JSON.stringify(payload)),
+    multipartTextPart(boundary, 'file_bindings', JSON.stringify(bindingMetadata)),
+  ];
+  const fileHeaderParts = fileBindings.map((binding) => multipartFileHeader(boundary, binding));
+  const closingPart = `--${boundary}--\r\n`;
+  const contentLength = [
+    ...textParts,
+    ...fileHeaderParts,
+    ...fileBindings.map(() => '\r\n'),
+    closingPart,
+  ].reduce((total, part) => total + Buffer.byteLength(part), 0)
+    + fileBindings.reduce((total, binding) => total + binding.size, 0);
+
+  return {
+    body: multipartFileBody(boundary, payload, bindingMetadata, fileBindings),
+    headers: {
+      'Content-Type': `multipart/form-data; boundary=${boundary}`,
+      'Content-Length': String(contentLength),
+    },
+    duplex: 'half',
+  };
 }
 
 function normalizeBackendError(status, payload) {
@@ -197,6 +238,7 @@ export async function httpRequest({
   method = 'POST',
   path,
   body,
+  multipart = false,
   requireAuth = true,
 }) {
   await maybeRefreshDevPortalAuth(runtime);
@@ -211,21 +253,41 @@ export async function httpRequest({
   };
 
   const headers = {
-    'Content-Type': 'application/json',
     'X-Notis-CLI-Version': runtime.cliVersion,
     'X-Notis-Request-Id': requestId,
   };
+  if (!multipart) {
+    headers['Content-Type'] = 'application/json';
+  }
 
   if (requireAuth && runtime.jwt) {
     headers.Authorization = `Bearer ${runtime.jwt}`;
   }
 
+  const resolveBody = () => {
+    if (!multipart) {
+      return {
+        body: body ? JSON.stringify(body) : undefined,
+        headers: {},
+      };
+    }
+    if (typeof body === 'function') {
+      return body();
+    }
+    return {
+      body,
+      headers: {},
+    };
+  };
+
   try {
+    let requestBody = resolveBody();
     let response = await fetch(`${runtime.apiBase}${path}`, {
       method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
+      headers: { ...headers, ...requestBody.headers },
+      body: requestBody.body,
       signal: controller.signal,
+      ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
     });
 
     let payload = null;
@@ -243,11 +305,13 @@ export async function httpRequest({
           headers.Authorization = `Bearer ${runtime.jwt}`;
         }
         resetTimeout();
+        requestBody = resolveBody();
         response = await fetch(`${runtime.apiBase}${path}`, {
           method,
-          headers,
-          body: body ? JSON.stringify(body) : undefined,
+          headers: { ...headers, ...requestBody.headers },
+          body: requestBody.body,
           signal: controller.signal,
+          ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
         });
         try {
           payload = await response.json();
@@ -302,22 +366,43 @@ export async function callTool({
   toolName,
   arguments_: argumentsPayload = {},
   idempotencyKey,
+  fileBindings = [],
 }) {
   const requestId = idempotencyKey || (runtime.mutating ? randomUUID() : null);
+  const payload = {
+    tool_name: toolName,
+    arguments: argumentsPayload,
+    idempotency_key: requestId,
+    cli_context: {
+      output_mode: runtime.outputMode,
+      profile: runtime.profileName,
+      cwd: process.cwd(),
+      agent_mode: runtime.agentMode,
+      cli_version: runtime.cliVersion,
+    },
+  };
+
+  if (Array.isArray(fileBindings) && fileBindings.length) {
+    const bindingMetadata = fileBindings.map((binding) => {
+      const {
+        contentType,
+        localPath,
+        ...metadata
+      } = binding;
+      return metadata;
+    });
+
+    return httpRequest({
+      runtime,
+      path: '/cli_tools',
+      body: () => createMultipartFileUpload(payload, bindingMetadata, fileBindings),
+      multipart: true,
+    });
+  }
+
   return httpRequest({
     runtime,
     path: '/cli_tools',
-    body: {
-      tool_name: canonicalizeToolName(toolName),
-      arguments: argumentsPayload,
-      idempotency_key: requestId,
-      cli_context: {
-        output_mode: runtime.outputMode,
-        profile: runtime.profileName,
-        cwd: process.cwd(),
-        agent_mode: runtime.agentMode,
-        cli_version: runtime.cliVersion,
-      },
-    },
+    body: payload,
   });
 }

package/template/packages/sdk/package.json

@@ -14,6 +14,9 @@
     "src",
     "template"
   ],
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
   "peerDependencies": {
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0",
@@ -21,6 +24,9 @@
     "@vitejs/plugin-react": ">=4.0.0"
   },
   "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
     "typescript": "^5.0.0"
   }
 }