@sandbaseai/cli 0.3.3 → 0.3.6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -0
- package/assets/mcp-bridge.mjs +7 -2
- package/dist/agent/client.d.ts +3 -2
- package/dist/agent/client.js +10 -3
- package/dist/agent/commands.d.ts +10 -2
- package/dist/agent/commands.js +109 -23
- package/package.json +1 -1
- package/skills/sandbase/SKILL.md +101 -20
- package/skills/sandbase/skill.json +1 -1
package/README.md
CHANGED
|
@@ -286,6 +286,7 @@ sandbase inspect sandbase_twitter_web_search_timeline # fields, price, rea
|
|
|
286
286
|
sandbase run sandbase_twitter_web_search_timeline -i '{"keyword":"AI agents"}'
|
|
287
287
|
sandbase run <video_tool> -i '{"prompt":"..."}' -w -o result.json # wait with backoff, save output to disk
|
|
288
288
|
sandbase runs get -r <run_id> -w -o result.json # resume a long run instead of re-running it
|
|
289
|
+
sandbase upload ./photo.png # local image/audio/video -> public URL for tools that take a URL
|
|
289
290
|
sandbase runs list | sandbase balance
|
|
290
291
|
```
|
|
291
292
|
|
package/assets/mcp-bridge.mjs
CHANGED
|
@@ -19,6 +19,8 @@ import { pathToFileURL } from "node:url";
|
|
|
19
19
|
const allowedClients = new Set(["codex", "claude-code", "cursor", "gemini-cli", "hermes", "openclaw", "opencode", "qwen-code", "windsurf", "cursor-cli", "kimi-cli", "kiro", "kiro-cli", "amp", "crush", "iflow-cli", "warp", "claude-desktop", "cowork", "antigravity", "trae", "qoder", "workbuddy", "pi"]);
|
|
20
20
|
const BILLING_URL = "https://www.sandbase.ai/console/billing";
|
|
21
21
|
const RECONNECT = "npx -y @sandbaseai/cli@latest connect";
|
|
22
|
+
const KEYS_URL = "https://www.sandbase.ai/console/keys";
|
|
23
|
+
const SPENDING_LIMIT = `This SandBase key reached the spending limit set on it. Stop and tell the user: topping up does not lift it; they can raise or remove the limit at ${KEYS_URL}, then retry.`;
|
|
22
24
|
// Tool calls get no bridge-side deadline (long synchronous tools must be able to
|
|
23
25
|
// finish); control-plane methods are bounded so offline detection stays quick.
|
|
24
26
|
const CONTROL_TIMEOUT_MS = 60_000;
|
|
@@ -71,9 +73,11 @@ export function isIdempotentRequest(request) {
|
|
|
71
73
|
}
|
|
72
74
|
export function hintFor(message) {
|
|
73
75
|
const text = String(message || "").toLowerCase();
|
|
76
|
+
// Before auth: "API key spending limit exceeded" is neither a sign-in nor a balance problem.
|
|
77
|
+
if (/spending limit/.test(text)) return SPENDING_LIMIT;
|
|
74
78
|
// Auth first: "API key not found" is a sign-in problem, not a misspelled tool.
|
|
75
79
|
if (/unauthori[sz]ed|api key|credential|revoked|expired|authenticat|sign-in|signin/.test(text)) return `The SandBase sign-in is not valid. Ask the user to run \`${RECONNECT}\` in a terminal.`;
|
|
76
|
-
if (/insufficient (balance|credit|funds)|payment required|
|
|
80
|
+
if (/insufficient (balance|credit|funds)|payment required|top up/.test(text)) return `Tell the user their SandBase balance is insufficient; they can top up at ${BILLING_URL}.`;
|
|
77
81
|
if (/rate.?limit|too many requests|429/.test(text)) return "Rate limited: wait 10-30 seconds, then retry once.";
|
|
78
82
|
if (/run .*not found|task not found/.test(text)) return "Use the prediction_id/run_id returned by sandbase_run, or list recent runs with sandbase_runs. Agent Service runs also need service_id.";
|
|
79
83
|
if (/invalid service request|unknown tool|tool(?: '[^']*')? (?:was )?not found|model not found|tool name is required/.test(text)) return "Check the exact tool name with sandbase_discover (names look like sandbase_twitter_web_search_timeline), then sandbase_inspect it.";
|
|
@@ -86,7 +90,8 @@ function httpFailure(status, text, host) {
|
|
|
86
90
|
try { const parsed = JSON.parse(text); const e = parsed?.error; detail = typeof e === "string" ? e : typeof e?.message === "string" ? e.message : typeof parsed?.message === "string" ? parsed.message : ""; } catch { /* non-JSON gateway body is never forwarded */ }
|
|
87
91
|
const suffix = detail ? `: ${detail.slice(0, 300)}` : "";
|
|
88
92
|
if (status === 401) return `SandBase rejected the saved sign-in (401)${suffix}. Ask the user to run \`${RECONNECT}\` in a terminal to sign in again.`;
|
|
89
|
-
if (status === 402
|
|
93
|
+
if (status === 402 && /spending limit/i.test(detail)) return `${SPENDING_LIMIT} (402${suffix})`;
|
|
94
|
+
if (status === 402) return `SandBase balance is insufficient (402)${suffix}. The user can top up at ${BILLING_URL}.`;
|
|
90
95
|
if (status === 403) return `This SandBase credential is not allowed for this request (403)${suffix}. Ask the user to run \`${RECONNECT}\`.`;
|
|
91
96
|
if (status === 429) return `SandBase rate limit reached (429)${suffix}. Wait 10-30 seconds, then retry once.`;
|
|
92
97
|
if (status >= 500) return `SandBase returned HTTP ${status} from ${host}${suffix}. Temporary server error: retry in a minute; the user can run \`sandbase doctor\` if it persists.`;
|
package/dist/agent/client.d.ts
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
export declare const DEFAULT_MCP_URL = "https://api.sandbase.ai/v1/mcp";
|
|
2
2
|
export declare const UNREACHABLE_HINT = "Check this machine's network, proxy, or VPN, then run `sandbase doctor` and retry.";
|
|
3
|
-
export type ErrorCode = "AUTH_REQUIRED" | "AUTH_FAILED" | "INSUFFICIENT_BALANCE" | "FORBIDDEN" | "NOT_FOUND" | "RATE_LIMITED" | "INVALID_INPUT" | "NETWORK" | "UPSTREAM" | "RUN_FAILED" | "INVALID_RESPONSE" | "TOOL_ERROR" | "USAGE";
|
|
3
|
+
export type ErrorCode = "AUTH_REQUIRED" | "AUTH_FAILED" | "INSUFFICIENT_BALANCE" | "SPENDING_LIMIT" | "FORBIDDEN" | "NOT_FOUND" | "RATE_LIMITED" | "INVALID_INPUT" | "NETWORK" | "UPSTREAM" | "RUN_FAILED" | "INVALID_RESPONSE" | "TOOL_ERROR" | "USAGE";
|
|
4
4
|
export declare class SandBaseError extends Error {
|
|
5
5
|
readonly code: ErrorCode;
|
|
6
6
|
readonly hint?: string | undefined;
|
|
@@ -12,6 +12,7 @@ export declare function webUrl(env?: NodeJS.ProcessEnv): string;
|
|
|
12
12
|
export declare function billingUrl(env?: NodeJS.ProcessEnv): string;
|
|
13
13
|
export declare function keysUrl(env?: NodeJS.ProcessEnv): string;
|
|
14
14
|
export declare const CONNECT_COMMAND = "npx -y @sandbaseai/cli@latest connect";
|
|
15
|
+
export declare function spendingLimitHint(env?: NodeJS.ProcessEnv): string;
|
|
15
16
|
export declare function validMcpUrl(value: unknown): string | undefined;
|
|
16
17
|
export interface Endpoint {
|
|
17
18
|
credential: string;
|
|
@@ -48,7 +49,7 @@ export interface ToolOutput {
|
|
|
48
49
|
export type FetchLike = (url: string, init: {
|
|
49
50
|
method: string;
|
|
50
51
|
headers: Record<string, string>;
|
|
51
|
-
body: string;
|
|
52
|
+
body: string | FormData;
|
|
52
53
|
signal: AbortSignal;
|
|
53
54
|
}) => Promise<{
|
|
54
55
|
ok: boolean;
|
package/dist/agent/client.js
CHANGED
|
@@ -27,6 +27,7 @@ export function webUrl(env = process.env) { return (env.SANDBASE_WEB_URL || "htt
|
|
|
27
27
|
export function billingUrl(env = process.env) { return `${webUrl(env)}/console/billing`; }
|
|
28
28
|
export function keysUrl(env = process.env) { return `${webUrl(env)}/console/keys`; }
|
|
29
29
|
export const CONNECT_COMMAND = "npx -y @sandbaseai/cli@latest connect";
|
|
30
|
+
export function spendingLimitHint(env = process.env) { return `Stop and tell the user: this key's spending limit is reached. Topping up does not lift it; they can raise or remove the limit at ${keysUrl(env)}, then retry.`; }
|
|
30
31
|
export function validMcpUrl(value) {
|
|
31
32
|
if (typeof value !== "string")
|
|
32
33
|
return undefined;
|
|
@@ -120,10 +121,14 @@ export function describeNetworkFailure(error) {
|
|
|
120
121
|
/** Map a server/tool error message to the most useful next step. */
|
|
121
122
|
export function hintForMessage(message, env = process.env) {
|
|
122
123
|
const text = message.toLowerCase();
|
|
124
|
+
// "API key spending limit exceeded" mentions the key but is not a sign-in problem, and
|
|
125
|
+
// topping up does not lift it, so it is checked before both auth and balance.
|
|
126
|
+
if (/spending limit/.test(text))
|
|
127
|
+
return spendingLimitHint(env);
|
|
123
128
|
// Auth first: "API key not found" is a sign-in problem, not a misspelled tool.
|
|
124
129
|
if (/unauthori[sz]ed|api key|credential|revoked|expired|authenticat|sign-in|signin/.test(text))
|
|
125
130
|
return `Sign in again with \`${CONNECT_COMMAND}\`, or check SANDBASE_API_KEY.`;
|
|
126
|
-
if (/insufficient (balance|credit|funds)|payment required|
|
|
131
|
+
if (/insufficient (balance|credit|funds)|payment required|top up/.test(text))
|
|
127
132
|
return `Top up at ${billingUrl(env)}, then retry.`;
|
|
128
133
|
if (/rate.?limit|too many requests|429/.test(text))
|
|
129
134
|
return "Rate limited. Wait 10-30 seconds, then retry once.";
|
|
@@ -148,8 +153,10 @@ export function httpError(status, body, host, env = process.env) {
|
|
|
148
153
|
const detail = message ? `: ${message}` : "";
|
|
149
154
|
if (status === 401)
|
|
150
155
|
return new SandBaseError("AUTH_FAILED", `SandBase rejected the saved sign-in or API key (401)${detail}.`, `Sign in again with \`${CONNECT_COMMAND}\`, or create a new key at ${keysUrl(env)}.`, status);
|
|
156
|
+
if (status === 402 && /spending limit/i.test(message))
|
|
157
|
+
return new SandBaseError("SPENDING_LIMIT", `This credential reached the spending limit set on it in the SandBase Dashboard (402)${detail}.`, spendingLimitHint(env), status);
|
|
151
158
|
if (status === 402)
|
|
152
|
-
return new SandBaseError("INSUFFICIENT_BALANCE", `Insufficient balance
|
|
159
|
+
return new SandBaseError("INSUFFICIENT_BALANCE", `Insufficient balance (402)${detail}.`, `Top up at ${billingUrl(env)}, then retry.`, status);
|
|
153
160
|
if (status === 403)
|
|
154
161
|
return new SandBaseError("FORBIDDEN", `This credential is not allowed to call ${host} (403)${detail}.`, `Use a credential issued by \`${CONNECT_COMMAND}\` or a full API key from ${keysUrl(env)}.`, status);
|
|
155
162
|
if (status === 404)
|
|
@@ -243,7 +250,7 @@ export class SandBaseMCPClient {
|
|
|
243
250
|
return toolOutput(await this.rpc("tools/call", { name, arguments: args }), this.env);
|
|
244
251
|
}
|
|
245
252
|
}
|
|
246
|
-
const serverErrorCodes = { tool_not_found: "NOT_FOUND", run_not_found: "NOT_FOUND", invalid_arguments: "INVALID_INPUT", insufficient_balance: "INSUFFICIENT_BALANCE", rate_limited: "RATE_LIMITED", unauthorized: "AUTH_FAILED", run_failed: "RUN_FAILED", upstream_error: "UPSTREAM", internal_error: "UPSTREAM" };
|
|
253
|
+
const serverErrorCodes = { tool_not_found: "NOT_FOUND", run_not_found: "NOT_FOUND", invalid_arguments: "INVALID_INPUT", insufficient_balance: "INSUFFICIENT_BALANCE", spending_limit: "SPENDING_LIMIT", rate_limited: "RATE_LIMITED", unauthorized: "AUTH_FAILED", run_failed: "RUN_FAILED", upstream_error: "UPSTREAM", internal_error: "UPSTREAM" };
|
|
247
254
|
export function toolOutput(result, env = process.env) {
|
|
248
255
|
const value = (result || {});
|
|
249
256
|
const text = (value.content || []).filter(item => item?.type === "text" && typeof item.text === "string").map(item => item.text).join("\n");
|
package/dist/agent/commands.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { type FetchLike } from "./client.js";
|
|
2
|
-
export declare const agentCommands: readonly ["discover", "inspect", "run", "runs", "balance", "keys"];
|
|
2
|
+
export declare const agentCommands: readonly ["discover", "inspect", "run", "runs", "upload", "balance", "keys"];
|
|
3
3
|
export type AgentCommand = typeof agentCommands[number];
|
|
4
4
|
export declare function isAgentCommand(value: string | undefined): value is AgentCommand;
|
|
5
5
|
export interface AgentDeps {
|
|
@@ -11,10 +11,18 @@ export interface AgentDeps {
|
|
|
11
11
|
now?: () => number;
|
|
12
12
|
stdin?: () => Promise<string>;
|
|
13
13
|
}
|
|
14
|
-
export declare const agentUsage = "SandBase agent commands (same capabilities as the sandbase_* MCP tools):\n sandbase discover -q \"<what you need>\" [-t llm|api|multimodal|embedding|service] [--vendor <slug>] [-l 10] [-j]\n sandbase inspect <tool_name> [-j]\n sandbase run <tool_name> [-i '<json>' | -f input.json] [-w] [--timeout 300] [-o result.json] [-j]\n sandbase runs get -r <run_id> [--service <svc_id>] [-w] [--timeout 300] [-o result.json] [-j]\n sandbase runs list [-l 10] [--model <model>] [--service <svc_id>] [-j]\n sandbase balance [-j]\n sandbase keys add -k - (reads the key from stdin) | keys list | keys remove\nGlobal: --client <client> picks a connected client's credential; SANDBASE_API_KEY overrides all; -j prints JSON.";
|
|
14
|
+
export declare const agentUsage = "SandBase agent commands (same capabilities as the sandbase_* MCP tools):\n sandbase discover -q \"<what you need>\" [-t llm|api|multimodal|embedding|service] [--vendor <slug>] [-l 10] [-j]\n sandbase inspect <tool_name> [-j]\n sandbase run <tool_name> [-i '<json>' | -f input.json] [-w] [--timeout 300] [-o result.json] [-j]\n sandbase runs get -r <run_id> [--service <svc_id>] [-w] [--timeout 300] [-o result.json] [-j]\n sandbase runs list [-l 10] [--model <model>] [--service <svc_id>] [-j]\n sandbase upload <file> [-j] (local image/audio/video \u2192 public URL for tools that take a URL)\n sandbase balance [-j]\n sandbase keys add -k - (reads the key from stdin) | keys list | keys remove\nGlobal: --client <client> picks a connected client's credential; SANDBASE_API_KEY overrides all; -j prints JSON.";
|
|
15
15
|
export declare function formatPrice(pricing: unknown): string;
|
|
16
|
+
/**
|
|
17
|
+
* Files the run produced. The server returns media outputs as `[{url, …}]`
|
|
18
|
+
* (content_type is only added when it can be inferred), so an entry counts as a
|
|
19
|
+
* file when it has a `url` and carries no content of its own. A scraped page's
|
|
20
|
+
* `{url, markdown}`, a tweet row, or a nested avatar is content, not a file.
|
|
21
|
+
*/
|
|
22
|
+
export declare function generatedFiles(output: unknown): string[];
|
|
16
23
|
/** Resolve a root-level local $ref (#/components/schemas/X, #/$defs/X, #/definitions/X) so agents see real fields. */
|
|
17
24
|
export declare function resolveSchema(schema: unknown): Record<string, unknown>;
|
|
25
|
+
export declare function uploadUrlFor(mcpUrl: string): string;
|
|
18
26
|
/** Shows at most a quarter of the key (capped at 6 chars) so short keys are not mostly revealed. */
|
|
19
27
|
export declare function maskKey(key: string): string;
|
|
20
28
|
export declare function runAgentCommand(command: AgentCommand, argv: string[], deps?: AgentDeps): Promise<number>;
|
package/dist/agent/commands.js
CHANGED
|
@@ -3,13 +3,13 @@
|
|
|
3
3
|
// agent without MCP (or with a broken MCP session) still has a working path,
|
|
4
4
|
// and so large results can go straight to disk with -o instead of the context.
|
|
5
5
|
import { constants as fsConstants } from "node:fs";
|
|
6
|
-
import { access, readFile, rm, writeFile } from "node:fs/promises";
|
|
7
|
-
import { dirname, resolve as resolvePath } from "node:path";
|
|
6
|
+
import { access, readFile, rm, stat, writeFile } from "node:fs/promises";
|
|
7
|
+
import { basename, dirname, extname, resolve as resolvePath } from "node:path";
|
|
8
8
|
import { parseArgs } from "node:util";
|
|
9
9
|
import { atomicWrite } from "../fs-safe.js";
|
|
10
|
-
import { CONNECT_COMMAND, keyFilePath, keysUrl, readStoredKey, resolveEndpoint, SandBaseError, SandBaseMCPClient, toolOutput, validMcpUrl } from "./client.js";
|
|
10
|
+
import { CONNECT_COMMAND, describeNetworkFailure, httpError, keyFilePath, keysUrl, readStoredKey, resolveEndpoint, SandBaseError, SandBaseMCPClient, toolOutput, validMcpUrl } from "./client.js";
|
|
11
11
|
import { updateNotice } from "./update.js";
|
|
12
|
-
export const agentCommands = ["discover", "inspect", "run", "runs", "balance", "keys"];
|
|
12
|
+
export const agentCommands = ["discover", "inspect", "run", "runs", "upload", "balance", "keys"];
|
|
13
13
|
export function isAgentCommand(value) { return agentCommands.includes(value); }
|
|
14
14
|
export const agentUsage = `SandBase agent commands (same capabilities as the sandbase_* MCP tools):
|
|
15
15
|
sandbase discover -q "<what you need>" [-t llm|api|multimodal|embedding|service] [--vendor <slug>] [-l 10] [-j]
|
|
@@ -17,6 +17,7 @@ export const agentUsage = `SandBase agent commands (same capabilities as the san
|
|
|
17
17
|
sandbase run <tool_name> [-i '<json>' | -f input.json] [-w] [--timeout 300] [-o result.json] [-j]
|
|
18
18
|
sandbase runs get -r <run_id> [--service <svc_id>] [-w] [--timeout 300] [-o result.json] [-j]
|
|
19
19
|
sandbase runs list [-l 10] [--model <model>] [--service <svc_id>] [-j]
|
|
20
|
+
sandbase upload <file> [-j] (local image/audio/video → public URL for tools that take a URL)
|
|
20
21
|
sandbase balance [-j]
|
|
21
22
|
sandbase keys add -k - (reads the key from stdin) | keys list | keys remove
|
|
22
23
|
Global: --client <client> picks a connected client's credential; SANDBASE_API_KEY overrides all; -j prints JSON.`;
|
|
@@ -82,20 +83,39 @@ function hintLines(hints) {
|
|
|
82
83
|
}
|
|
83
84
|
function printHints(out, ...sources) { const lines = sources.flatMap(hintLines); if (lines.length)
|
|
84
85
|
out.print(["", "Hints:", ...lines.map(line => ` - ${line}`)].join("\n")); }
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
86
|
+
/**
|
|
87
|
+
* Files the run produced. The server returns media outputs as `[{url, …}]`
|
|
88
|
+
* (content_type is only added when it can be inferred), so an entry counts as a
|
|
89
|
+
* file when it has a `url` and carries no content of its own. A scraped page's
|
|
90
|
+
* `{url, markdown}`, a tweet row, or a nested avatar is content, not a file.
|
|
91
|
+
*/
|
|
92
|
+
export function generatedFiles(output) {
|
|
93
|
+
const isUrl = (value) => typeof value === "string" && /^https?:\/\/\S+$/.test(value);
|
|
94
|
+
// Keys that make an object a data row rather than a produced file.
|
|
95
|
+
const contentKeys = ["text", "markdown", "md", "html", "content", "title", "body", "snippet", "caption", "summary", "data", "items", "results", "children", "comments", "author", "user"];
|
|
96
|
+
const fileEntry = (entry) => {
|
|
97
|
+
if (isUrl(entry))
|
|
98
|
+
return entry;
|
|
99
|
+
if (!entry || typeof entry !== "object" || Array.isArray(entry))
|
|
100
|
+
return undefined;
|
|
101
|
+
const record = entry;
|
|
102
|
+
if (!isUrl(record.url))
|
|
103
|
+
return undefined;
|
|
104
|
+
return contentKeys.some(key => record[key] !== undefined) ? undefined : record.url;
|
|
105
|
+
};
|
|
106
|
+
const list = (value) => {
|
|
107
|
+
const entries = Array.isArray(value) ? value : [value];
|
|
108
|
+
return entries.map(fileEntry).filter((url) => !!url);
|
|
109
|
+
};
|
|
110
|
+
let files = list(output);
|
|
111
|
+
// {images: [{url}], seed: 1} / {video: {url}}: a media-named key holds the files.
|
|
112
|
+
if (!files.length && output && typeof output === "object" && !Array.isArray(output)) {
|
|
113
|
+
for (const [key, value] of Object.entries(output)) {
|
|
114
|
+
if (/^(image|video|audio|file|media|clip|frame)s?$/i.test(key))
|
|
115
|
+
files = files.concat(list(value));
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
return [...new Set(files)].slice(0, 20);
|
|
99
119
|
}
|
|
100
120
|
function shellQuote(value) { return `'${value.replace(/'/g, `'\\''`)}'`; }
|
|
101
121
|
const commonOptions = { json: { type: "boolean", short: "j" }, client: { type: "string" }, help: { type: "boolean", short: "h" } };
|
|
@@ -218,9 +238,9 @@ function printRun(out, view, outputFile) {
|
|
|
218
238
|
if (view.cost === undefined && view.cost_status === "settling")
|
|
219
239
|
lines.push("Cost: settling (see `sandbase runs list` shortly)");
|
|
220
240
|
if (phase === "succeeded" && hasOutput(view)) {
|
|
221
|
-
const
|
|
222
|
-
if (
|
|
223
|
-
lines.push("Files:", ...
|
|
241
|
+
const files = generatedFiles(view.output);
|
|
242
|
+
if (files.length)
|
|
243
|
+
lines.push("Files:", ...files.map(url => ` ${url}`));
|
|
224
244
|
if (outputFile)
|
|
225
245
|
lines.push(`Saved output to ${outputFile}`);
|
|
226
246
|
else {
|
|
@@ -442,6 +462,71 @@ async function runs(argv, out, env, deps, fetchImpl) {
|
|
|
442
462
|
}
|
|
443
463
|
throw new SandBaseError("USAGE", "Use `sandbase runs get -r <run_id>` or `sandbase runs list`.");
|
|
444
464
|
}
|
|
465
|
+
// What /v1/upload accepts, by extension. Server limits are 20/50/500 MB; video is
|
|
466
|
+
// capped at 100 MB here because the API sits behind Cloudflare's request-body limit.
|
|
467
|
+
const MB = 1024 * 1024;
|
|
468
|
+
const uploadTypes = {
|
|
469
|
+
".jpg": { mime: "image/jpeg", kind: "image", max: 20 * MB }, ".jpeg": { mime: "image/jpeg", kind: "image", max: 20 * MB }, ".png": { mime: "image/png", kind: "image", max: 20 * MB }, ".webp": { mime: "image/webp", kind: "image", max: 20 * MB }, ".gif": { mime: "image/gif", kind: "image", max: 20 * MB },
|
|
470
|
+
".mp3": { mime: "audio/mpeg", kind: "audio", max: 50 * MB }, ".m4a": { mime: "audio/mp4", kind: "audio", max: 50 * MB }, ".wav": { mime: "audio/wav", kind: "audio", max: 50 * MB }, ".ogg": { mime: "audio/ogg", kind: "audio", max: 50 * MB }, ".aac": { mime: "audio/aac", kind: "audio", max: 50 * MB }, ".flac": { mime: "audio/flac", kind: "audio", max: 50 * MB },
|
|
471
|
+
".mp4": { mime: "video/mp4", kind: "video", max: 100 * MB }, ".mov": { mime: "video/quicktime", kind: "video", max: 100 * MB }, ".webm": { mime: "video/webm", kind: "video", max: 100 * MB },
|
|
472
|
+
};
|
|
473
|
+
export function uploadUrlFor(mcpUrl) { const url = new URL(mcpUrl); url.pathname = url.pathname.replace(/\/mcp$/, "/upload"); url.search = ""; return url.href; }
|
|
474
|
+
async function upload(argv, out, env, fetchImpl) {
|
|
475
|
+
const { values, positionals } = parse(argv, { file: { type: "string", short: "f" } });
|
|
476
|
+
const path = (values.file ?? positionals[0] ?? "").trim();
|
|
477
|
+
if (!path)
|
|
478
|
+
throw new SandBaseError("USAGE", "Pass the local file to upload.", "Example: sandbase upload ./photo.png");
|
|
479
|
+
const type = uploadTypes[extname(path).toLowerCase()];
|
|
480
|
+
if (!type)
|
|
481
|
+
throw new SandBaseError("USAGE", `Cannot upload ${basename(path)}: only images (jpg, png, webp, gif), audio (mp3, m4a, wav, ogg, aac, flac) and video (mp4, mov, webm) are accepted.`);
|
|
482
|
+
let size;
|
|
483
|
+
try {
|
|
484
|
+
const info = await stat(path);
|
|
485
|
+
if (!info.isFile())
|
|
486
|
+
throw new Error("not a file");
|
|
487
|
+
size = info.size;
|
|
488
|
+
}
|
|
489
|
+
catch {
|
|
490
|
+
throw new SandBaseError("USAGE", `Cannot read ${path}: it does not exist or is not a file.`);
|
|
491
|
+
}
|
|
492
|
+
if (size > type.max)
|
|
493
|
+
throw new SandBaseError("USAGE", `${basename(path)} is ${Math.ceil(size / MB)} MB; the ${type.kind} limit is ${type.max / MB} MB.`, type.kind === "video" ? "Trim or compress the video, or pass a URL where it is already hosted." : "Compress the file, or pass a URL where it is already hosted.");
|
|
494
|
+
const endpoint = await resolveEndpoint(values.client ? { client: values.client } : {}, env);
|
|
495
|
+
const target = uploadUrlFor(endpoint.url);
|
|
496
|
+
const host = new URL(target).host;
|
|
497
|
+
const form = new FormData();
|
|
498
|
+
form.append("file", new Blob([await readFile(path)], { type: type.mime }), basename(path));
|
|
499
|
+
let response;
|
|
500
|
+
try {
|
|
501
|
+
response = await (fetchImpl ?? globalThis.fetch)(target, { method: "POST", headers: { authorization: `Bearer ${endpoint.credential}`, "x-sandbase-client": "cli" }, body: form, signal: AbortSignal.timeout(600_000) });
|
|
502
|
+
}
|
|
503
|
+
catch (error) {
|
|
504
|
+
throw new SandBaseError("NETWORK", `Upload to ${host} failed (${describeNetworkFailure(error)}).`, "Check the network, then retry; nothing is billed for uploads.");
|
|
505
|
+
}
|
|
506
|
+
const text = await response.text();
|
|
507
|
+
if (response.status === 403 && /insufficient_scope/.test(text))
|
|
508
|
+
throw new SandBaseError("FORBIDDEN", `This sign-in cannot upload files on ${host} yet (403).`, `Ask the user for a full API key from ${keysUrl(env)} and run the upload with SANDBASE_API_KEY set (never paste the key into chat).`, 403);
|
|
509
|
+
if (response.status === 404)
|
|
510
|
+
throw new SandBaseError("NOT_FOUND", `${host} does not accept file uploads (404).`, "Pass a URL where the file is already hosted instead.", 404);
|
|
511
|
+
if (!response.ok)
|
|
512
|
+
throw httpError(response.status, text, host, env);
|
|
513
|
+
let data;
|
|
514
|
+
try {
|
|
515
|
+
data = JSON.parse(text);
|
|
516
|
+
}
|
|
517
|
+
catch {
|
|
518
|
+
data = {};
|
|
519
|
+
}
|
|
520
|
+
const inner = (data.data && typeof data.data === "object" ? data.data : data);
|
|
521
|
+
if (typeof inner.url !== "string" || !inner.url)
|
|
522
|
+
throw new SandBaseError("INVALID_RESPONSE", `Expected an uploaded file URL from ${host}.`, "Retry once; run `sandbase doctor` if it persists.");
|
|
523
|
+
if (out.json) {
|
|
524
|
+
out.data(inner);
|
|
525
|
+
return 0;
|
|
526
|
+
}
|
|
527
|
+
out.print([`Uploaded ${basename(path)} (${inner.type ?? type.mime}, ${Math.max(1, Math.round(size / 1024))} KB)`, `URL: ${inner.url}`, ...(inner.duration_seconds ? [`Duration: ${trimNumber(inner.duration_seconds)}s`] : []), "", "Pass this URL to the tool's image/audio/video URL field. Anyone with the URL can read the file."].join("\n"));
|
|
528
|
+
return 0;
|
|
529
|
+
}
|
|
445
530
|
async function balance(argv, out, env, fetchImpl) {
|
|
446
531
|
const { values } = parse(argv, {});
|
|
447
532
|
const api = await client(values, env, fetchImpl);
|
|
@@ -527,8 +612,9 @@ export async function runAgentCommand(command, argv, deps = {}) {
|
|
|
527
612
|
: command === "inspect" ? await inspect(argv, out, env, deps.fetchImpl)
|
|
528
613
|
: command === "run" ? await run(argv, out, env, timing, deps.fetchImpl)
|
|
529
614
|
: command === "runs" ? await runs(argv, out, env, timing, deps.fetchImpl)
|
|
530
|
-
: command === "
|
|
531
|
-
: await
|
|
615
|
+
: command === "upload" ? await upload(argv, out, env, deps.fetchImpl)
|
|
616
|
+
: command === "balance" ? await balance(argv, out, env, deps.fetchImpl)
|
|
617
|
+
: await keys(argv, out, env, deps);
|
|
532
618
|
if (!json)
|
|
533
619
|
await notice();
|
|
534
620
|
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@sandbaseai/cli",
|
|
3
|
-
"version": "0.3.
|
|
3
|
+
"version": "0.3.6",
|
|
4
4
|
"mcpName": "io.github.sandbaseai/cli",
|
|
5
5
|
"description": "Give 25 AI clients—Claude Code, Codex, Cursor, Hermes, OpenClaw and more—2,000+ models and APIs through one MCP server and an agent-friendly CLI",
|
|
6
6
|
"type": "module",
|
package/skills/sandbase/SKILL.md
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: sandbase
|
|
3
|
-
version: 0.3.
|
|
3
|
+
version: 0.3.6
|
|
4
4
|
description: >-
|
|
5
5
|
Discover better ways to complete tasks. Proactively search SandBase (the
|
|
6
6
|
sandbase_discover MCP tool, or `sandbase discover` in a shell) before writing a
|
|
@@ -26,6 +26,26 @@ There are **two transports** with the same capabilities. Pick one before doing a
|
|
|
26
26
|
|
|
27
27
|
---
|
|
28
28
|
|
|
29
|
+
## 0. Set up
|
|
30
|
+
|
|
31
|
+
Do this when the user asks you to set up SandBase (for example "set up https://www.sandbase.ai/SKILL.md"), or when §1 finds neither transport. You run the steps yourself; the user only approves a sign-in in their browser.
|
|
32
|
+
|
|
33
|
+
1. Check Node.js 20 or newer: `node --version`. If it is missing or older, ask the user to install it from https://nodejs.org and stop.
|
|
34
|
+
2. Connect this client. Run in a shell, with your client id:
|
|
35
|
+
|
|
36
|
+
```sh
|
|
37
|
+
npx -y @sandbaseai/cli@latest connect --client <client-id>
|
|
38
|
+
```
|
|
39
|
+
|
|
40
|
+
Client ids: `claude-code`, `codex`, `cursor`, `windsurf`, `kiro`, `kiro-cli`, `gemini-cli`, `opencode`, `qwen-code`, `warp`, `cursor-cli`, `kimi-cli`, `amp`, `crush`, `hermes`, `openclaw`, `iflow-cli`, `antigravity`, `trae`, `qoder`, `workbuddy`, `pi`, `claude-desktop`, `cowork`, `chatgpt`. If you are not sure which one you are, omit `--client` to configure every installed client.
|
|
41
|
+
- It opens the browser for sign-in (new users get an account in the same step). Tell the user to approve it. If there is no browser, it prints a URL — show that URL to the user.
|
|
42
|
+
- It waits for the approval, so give the command a timeout of at least 5 minutes. If your shell cannot wait that long, ask the user to run the same command in their own terminal.
|
|
43
|
+
- Never ask the user to paste an API key into the chat.
|
|
44
|
+
3. When it reports the client as configured, tell the user to start a new session (or restart the app) so the `sandbase_*` tools load. Until then, use the CLI right away: `npx -y @sandbaseai/cli@latest discover -q "<what you need>"` (§3).
|
|
45
|
+
4. Keep this Skill installed. `connect` saves it for supported clients; if yours is not covered, save https://www.sandbase.ai/SKILL.md to your skills directory and enable it so it loads in future sessions.
|
|
46
|
+
|
|
47
|
+
---
|
|
48
|
+
|
|
29
49
|
## 1. Pick your transport
|
|
30
50
|
|
|
31
51
|
| Condition | Use | Setup |
|
|
@@ -33,20 +53,10 @@ There are **two transports** with the same capabilities. Pick one before doing a
|
|
|
33
53
|
| You have tools named `sandbase_discover`, `sandbase_run`, … | **MCP** (preferred) | None |
|
|
34
54
|
| No `sandbase_*` tools, but you can run shell commands | **CLI** | §3 |
|
|
35
55
|
| The MCP tools return "SandBase is unreachable" | **CLI** for `sandbase doctor`, then tell the user what it reports | §3 |
|
|
36
|
-
| Neither |
|
|
56
|
+
| Neither | Set up (§0) | §0 |
|
|
37
57
|
|
|
38
58
|
**Exception:** when you expect a **large result** (hundreds of rows, long transcripts, many files) and have a shell, use the CLI with `-o result.json` even if MCP is connected. MCP results land in your context; `-o` writes them to disk. Discovery and inspection are small, so use MCP for those regardless.
|
|
39
59
|
|
|
40
|
-
### 1.1 If neither transport is available
|
|
41
|
-
|
|
42
|
-
Tell the user to run this once in a terminal, approve the browser sign-in, and restart their AI client:
|
|
43
|
-
|
|
44
|
-
```sh
|
|
45
|
-
npx -y https://github.com/sandbaseai/cli/releases/latest/download/sandbaseai-cli.tgz connect
|
|
46
|
-
```
|
|
47
|
-
|
|
48
|
-
It configures the local MCP bridge and this Skill for every supported client it finds. No API key to paste. For checksum-verified installs, use the immutable assets on the [GitHub Releases page](https://github.com/sandbaseai/cli/releases).
|
|
49
|
-
|
|
50
60
|
---
|
|
51
61
|
|
|
52
62
|
## 2. Transport A — MCP tools (preferred)
|
|
@@ -74,15 +84,35 @@ Discovery, inspection, run status, and balance are **free**; only `sandbase_run`
|
|
|
74
84
|
|
|
75
85
|
**Agent Services** (`svc_…` names from `type: "service"`): pass `arguments: {"idempotency_key": "<unique>", "input": "..."}`; reuse the same key and input on retries. Poll with `sandbase_run_get({"run_id": ..., "service_id": "svc_…"})`; `succeeded`, `failed`, and `cancelled` are terminal.
|
|
76
86
|
|
|
87
|
+
### Run statuses
|
|
88
|
+
|
|
89
|
+
| Status | Meaning | Do this |
|
|
90
|
+
|---|---|---|
|
|
91
|
+
| `pending` | Accepted, waiting to start | Poll every 5–10 s |
|
|
92
|
+
| `running` | Executing (on the first `sandbase_run` reply this also covers a job whose files are still being copied) | Poll every 5–10 s |
|
|
93
|
+
| `completed` / `succeeded` | Done; `output` holds the result | Use or save the output. If `output` is missing, read `hints`: "still being transferred" means poll again in a few seconds; "no stored output" means stop polling |
|
|
94
|
+
| `failed` | Ended with an error; read `error` | Fix the input (inspect) and retry once, or pick another tool |
|
|
95
|
+
| `timeout` | Hit the provider's time limit | Retry once with a smaller job, or pick another tool |
|
|
96
|
+
| `cancelled` | Stopped on request (Agent Services only) | Nothing to poll |
|
|
97
|
+
|
|
98
|
+
Any other value means still in progress: keep polling. Statuses are lowercase. Most runs finish in 1–120 seconds; video can take several minutes.
|
|
99
|
+
|
|
77
100
|
---
|
|
78
101
|
|
|
79
102
|
## 3. Transport B — CLI (fallback)
|
|
80
103
|
|
|
81
104
|
```sh
|
|
82
|
-
sandbase --version || npx -y
|
|
105
|
+
sandbase --version || npx -y @sandbaseai/cli@latest --version
|
|
83
106
|
```
|
|
84
107
|
|
|
85
|
-
If `sandbase` is not installed, prefix every command with `npx -y
|
|
108
|
+
If `sandbase` is not installed, prefix every command with `npx -y @sandbaseai/cli@latest` (or install it: `npm install -g @sandbaseai/cli@latest`).
|
|
109
|
+
|
|
110
|
+
**Keep the CLI and this Skill on the same version.** Run `npx -y @sandbaseai/cli@latest setup` (it refreshes the CLI's MCP bridge and this Skill) when any of these is true:
|
|
111
|
+
|
|
112
|
+
- The CLI prints "Update available".
|
|
113
|
+
- `sandbase --version` does not match the `version` at the top of this file.
|
|
114
|
+
|
|
115
|
+
Always move both to the latest; never downgrade one to match the other. If they still differ after `setup`, save the latest copy from https://www.sandbase.ai/SKILL.md over this file.
|
|
86
116
|
|
|
87
117
|
**Authentication** is automatic once the user has run `connect` (it reuses that browser sign-in). Otherwise the CLI reports `AUTH_REQUIRED` with the exact fix; an API key also works via `SANDBASE_API_KEY` or `sandbase keys add -k <key>`. Never ask the user to paste a key into the chat.
|
|
88
118
|
|
|
@@ -99,11 +129,55 @@ If `sandbase` is not installed, prefix every command with `npx -y https://github
|
|
|
99
129
|
|
|
100
130
|
- Add `-j` for JSON output. Errors then look like `{"error": {"code", "message", "hint"}}`; follow `hint`.
|
|
101
131
|
- `-w` waits with backoff (default `--timeout 300` seconds). If the run is still going when the timeout elapses, the CLI prints the `runs get` command to resume — use it rather than re-running (re-running is billed again).
|
|
102
|
-
- `-o` writes only the tool's output (no envelope). Files
|
|
132
|
+
- `-o` writes only the tool's output (no envelope). In text mode, `Files:` lists the files the run produced; URLs inside data results are in the output itself.
|
|
103
133
|
- Exit code is `0` on success or still-running, `1` on failure (including a failed run), `2` on bad usage.
|
|
104
134
|
- If an error mentions a `run_id`, the run already started: resume it with `sandbase runs get -r <run_id> -w` — never re-run (that bills again).
|
|
105
135
|
- To store an API key without exposing it: `printf %s "$KEY" | sandbase keys add -k -`.
|
|
106
136
|
|
|
137
|
+
### Local files → URL
|
|
138
|
+
|
|
139
|
+
Many tools (image-to-video, voice cloning, transcription, image editing) take a **URL**, not a file. When the user's file is only on their machine, upload it first (free; needs a shell):
|
|
140
|
+
|
|
141
|
+
```sh
|
|
142
|
+
sandbase upload ./photo.png
|
|
143
|
+
# -> URL: https://…/uploads/2026/10/….png
|
|
144
|
+
```
|
|
145
|
+
|
|
146
|
+
Pass that URL in the tool's URL field (`image_url`, `audio_url`, `video_url`, …). Accepted: images (jpg, png, webp, gif) up to 20 MB, audio (mp3, m4a, wav, ogg, aac, flac) up to 50 MB, video (mp4, mov, webm) up to 100 MB. **Anyone with the URL can read the file**, so ask before uploading anything private. If the file is already online, pass its URL directly instead.
|
|
147
|
+
|
|
148
|
+
### Example flows
|
|
149
|
+
|
|
150
|
+
Compare two platforms (one discover and one run per source, small limits, results to disk):
|
|
151
|
+
|
|
152
|
+
```sh
|
|
153
|
+
sandbase discover -q "twitter posts"
|
|
154
|
+
sandbase discover -q "reddit posts"
|
|
155
|
+
sandbase inspect <twitter_tool> # read inputSchema, pass one search term
|
|
156
|
+
sandbase inspect <reddit_tool>
|
|
157
|
+
sandbase run <twitter_tool> -i '{"keyword":"AI agents","limit":10}' -w -o twitter.json
|
|
158
|
+
sandbase run <reddit_tool> -i '{"query":"AI agents","limit":10}' -w -o reddit.json
|
|
159
|
+
# then read both files and compare
|
|
160
|
+
```
|
|
161
|
+
|
|
162
|
+
Turn a local photo into a video (upload, then an async run you poll):
|
|
163
|
+
|
|
164
|
+
```sh
|
|
165
|
+
sandbase upload ./photo.png # -> URL: https://…
|
|
166
|
+
sandbase discover -q "image to video"
|
|
167
|
+
sandbase inspect <video_tool>
|
|
168
|
+
sandbase run <video_tool> -i '{"image_url":"https://…","prompt":"slow pan"}'
|
|
169
|
+
# -> Run: <run_id> Status: running
|
|
170
|
+
sandbase runs get -r <run_id> -w -o video.json # waits, then saves the output
|
|
171
|
+
```
|
|
172
|
+
|
|
173
|
+
Large or reusable input: write the JSON to a file and pass it with `-f`:
|
|
174
|
+
|
|
175
|
+
```sh
|
|
176
|
+
sandbase run <tool_name> -f params.json -w -o result.json
|
|
177
|
+
```
|
|
178
|
+
|
|
179
|
+
Field names above are placeholders; always use the ones from `inspect`.
|
|
180
|
+
|
|
107
181
|
---
|
|
108
182
|
|
|
109
183
|
## 4. When to use SandBase — and when not
|
|
@@ -129,7 +203,9 @@ Do not use SandBase for purely local work (editing files, reasoning over code al
|
|
|
129
203
|
- Chinese works and aliases are expanded: `推特`, `小红书`, `抖音`, `文生视频`, `图片生成`.
|
|
130
204
|
- Narrow with `type` (`llm`, `api`, `multimodal`, `embedding`, `service`) or `vendor` (`openai`, `twitter`, `kling`).
|
|
131
205
|
- Split multi-source tasks: one discover per source ("twitter posts", then "reddit posts"), then run each.
|
|
206
|
+
- If no tool matches every word, discover returns the closest matches with a hint saying so; check their descriptions before using one.
|
|
132
207
|
- Zero results come with `hints`; read them before rephrasing.
|
|
208
|
+
- `inspect` hints name the inputs that take a file URL; for a local file use `sandbase upload` (§3).
|
|
133
209
|
|
|
134
210
|
---
|
|
135
211
|
|
|
@@ -139,6 +215,7 @@ Do not use SandBase for purely local work (editing files, reasoning over code al
|
|
|
139
215
|
- Many data endpoints are billed **per result** and limits often apply **per query**: three search terms with `limit: 10` can return 30 results. Pass one search term per call and start with small limits (5–10).
|
|
140
216
|
- Check `sandbase_account` before a batch of paid calls, and report cost when the user cares about budget (`cost` appears on `sandbase_run_get` and `sandbase_runs`).
|
|
141
217
|
- Never re-run a slow tool just because it is still running; poll it.
|
|
218
|
+
- A key can carry a **spending limit** set in the Dashboard. When it is reached, calls fail with "spending limit" until the user raises or removes it; topping up does not help.
|
|
142
219
|
|
|
143
220
|
---
|
|
144
221
|
|
|
@@ -149,10 +226,12 @@ Tool failures come back as error results whose text names the cause **and the ne
|
|
|
149
226
|
| Message contains | Do this |
|
|
150
227
|
|---|---|
|
|
151
228
|
| "unreachable" / `NETWORK` | Stop retrying. Tell the user to check network/proxy/VPN and run `sandbase doctor`. |
|
|
152
|
-
| "sign-in expired" / "rejected the saved sign-in" / 401 / `AUTH_FAILED` | Ask the user to run `npx -y
|
|
153
|
-
| "
|
|
229
|
+
| "sign-in expired" / "rejected the saved sign-in" / 401 / `AUTH_FAILED` | Ask the user to run `npx -y @sandbaseai/cli@latest connect`. |
|
|
230
|
+
| "spending limit" (402 / `SPENDING_LIMIT`) | Stop. Tell the user this key reached its spending limit; they can raise or remove it at https://www.sandbase.ai/console/keys. Topping up does not lift it. Do not retry until they do. |
|
|
231
|
+
| "insufficient" balance (402 / `INSUFFICIENT_BALANCE`) | Tell the user to top up at https://www.sandbase.ai/console/billing. |
|
|
154
232
|
| "not found" / "unknown tool" | Re-run `sandbase_discover`; copy `tool_name` exactly. |
|
|
155
233
|
| "invalid params" / schema | Re-run `sandbase_inspect`; pass exactly its `inputSchema` fields. |
|
|
234
|
+
| A tool rejects a local path where it wants a URL | Upload the file with `sandbase upload <file>` and pass the URL (§3). |
|
|
156
235
|
| "upstream" / "provider" / "capability call failed" | Retry once, then pick another tool from discover. |
|
|
157
236
|
| 429 / rate limit | Wait 10–30 seconds, retry once. |
|
|
158
237
|
|
|
@@ -171,11 +250,13 @@ Responses may include `hints` (and `warnings`): suggested next steps, caveats, o
|
|
|
171
250
|
3. **Prefer MCP when connected**; use the CLI when MCP is missing or broken, or to write large outputs to disk.
|
|
172
251
|
4. **Always inspect before running.** Never guess parameters; `inputSchema` is the source of truth.
|
|
173
252
|
5. **Keep discover queries short** and decompose multi-source tasks.
|
|
174
|
-
6. **Poll, don't re-run.** Slow tools return a run id; poll every 5–10 seconds.
|
|
253
|
+
6. **Poll, don't re-run.** Slow tools return a run id; poll every 5–10 seconds. Save large or file results with `-o <file>`.
|
|
175
254
|
7. **Start with conservative limits** (5–10 results).
|
|
176
255
|
8. **Report cost when relevant**, and check the balance before batches.
|
|
177
|
-
9. **Read error text and hints, and act on them.** They name the fix.
|
|
178
|
-
10. **
|
|
256
|
+
9. **Read error text and hints, and act on them.** They name the fix. A spending limit or empty balance is the user's call: stop and tell them.
|
|
257
|
+
10. **Keep the CLI and this Skill on the same, latest version** (§3).
|
|
258
|
+
11. **Ask before uploading private files**; uploaded URLs are publicly readable.
|
|
259
|
+
12. **Tool schemas and `sandbase --help` are authoritative** if they disagree with this document.
|
|
179
260
|
|
|
180
261
|
Before sending sensitive or regulated data, review the [SandBase Privacy Policy](https://www.sandbase.ai/privacy) and [Terms of Service](https://www.sandbase.ai/terms), plus the selected upstream provider's policies. Send only the minimum data needed.
|
|
181
262
|
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "sandbase",
|
|
3
|
-
"version": "0.3.
|
|
3
|
+
"version": "0.3.6",
|
|
4
4
|
"description": "Discover and run 2,000+ AI models and APIs (media generation, social data, search, scraping) through one MCP interface or CLI, paid per call from one balance.",
|
|
5
5
|
"author": "SandBase AI",
|
|
6
6
|
"license": "Apache-2.0",
|