thinyai 0.1.2 → 0.1.4

package/README.md

@@ -36,6 +36,7 @@ thiny                   # first launch runs setup, then starts chatting
 | `thiny` | Start the interactive agent. Runs first-time setup if needed. |
 | `thiny init` | (Re)run base setup — pick a model + agent name + API key. |
 | `thiny sui init` | Add Sui on-chain capabilities — pick a network + wallet. |
+| `thiny update` | Update to the latest published version (auto-detects bun/npm/pnpm). |
 | `thiny help` | Show all commands. |
 | `thiny --version` | Print the version. |
 

package/dist/bin.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env node
 
+// src/bin.ts
+import { spawnSync } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
 // src/main.ts
 import { createInterface } from "readline/promises";
 import { clearLine, cursorTo, emitKeypressEvents } from "readline";
 import { stdin, stdout } from "process";
-import { mkdirSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { z as z4 } from "zod";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { z as z6 } from "zod";
 
 // ../../packages/core/src/domain/messages.ts
 var systemMessage = (content) => ({ role: "system", content });
@@ -1310,6 +1314,300 @@ ${context}` : task;
   return { name: "agents", tools: [delegateTask, updatePlan] };
 }
 
+// ../../packages/adapters/signer-sui/src/index.ts
+import { SuiJsonRpcClient, getJsonRpcFullnodeUrl } from "@mysten/sui/jsonRpc";
+import { Transaction } from "@mysten/sui/transactions";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+var ZERO_ADDRESS = `0x${"0".repeat(64)}`;
+function suiSigner(opts = {}) {
+  const network = opts.network ?? "testnet";
+  const client = opts.client ?? new SuiJsonRpcClient({ url: opts.rpcUrl ?? getJsonRpcFullnodeUrl(network), network });
+  const keypair = opts.signer ?? (opts.secretKey ? Ed25519Keypair.fromSecretKey(opts.secretKey) : void 0);
+  const address = keypair?.getPublicKey().toSuiAddress();
+  return {
+    address,
+    network,
+    client,
+    hasKey: () => keypair !== void 0,
+    devInspect(tx, devOpts) {
+      return client.devInspectTransactionBlock({
+        sender: devOpts?.sender ?? address ?? ZERO_ADDRESS,
+        transactionBlock: tx
+      });
+    },
+    async signAndExecute(tx) {
+      if (!keypair) {
+        throw new Error("suiSigner.signAndExecute: no key configured (pass `secretKey` or `signer`).");
+      }
+      if (network === "mainnet" && opts.allowMainnet !== true) {
+        throw new Error(
+          "suiSigner: refusing to sign on mainnet. Pass `allowMainnet: true` to opt in."
+        );
+      }
+      const result = await client.signAndExecuteTransaction({
+        signer: keypair,
+        transaction: tx,
+        options: { showEffects: true }
+      });
+      await client.waitForTransaction({ digest: result.digest });
+      return { digest: result.digest, effects: result.effects ?? null };
+    }
+  };
+}
+
+// ../../packages/plugins/sui/src/index.ts
+import { z as z4 } from "zod";
+import { Transaction as Transaction2 } from "@mysten/sui/transactions";
+function explorerTxUrl(network, digest) {
+  return `https://suiscan.xyz/${network}/tx/${digest}`;
+}
+function suiPlugin(opts) {
+  const sig = opts.signer;
+  const resolve2 = typeof sig === "function" ? sig : () => sig;
+  const signerOrThrow = () => {
+    const s = resolve2();
+    if (!s) {
+      throw new Error(
+        "No Sui wallet configured yet. Call sui_setup to create or import one (or tell the user to run `thiny sui init`)."
+      );
+    }
+    return s;
+  };
+  const requireSimSuccess = opts.policy?.requireSimSuccess ?? true;
+  const executeTx = async (tx, toolName, approvalArgs, reason) => {
+    const signer = signerOrThrow();
+    const sim = await signer.devInspect(tx);
+    const status = sim.effects.status.status;
+    if (requireSimSuccess && status !== "success") {
+      throw new Error(`${toolName}: simulation failed (${sim.effects.status.error ?? status})`);
+    }
+    if (opts.policy?.maxGasBudgetMist !== void 0) {
+      const gas = sim.effects.gasUsed;
+      const estGas = BigInt(gas.computationCost) + BigInt(gas.storageCost);
+      if (estGas > opts.policy.maxGasBudgetMist) {
+        throw new Error(
+          `${toolName}: estimated gas ${estGas.toString()} MIST exceeds policy cap ${opts.policy.maxGasBudgetMist.toString()}.`
+        );
+      }
+    }
+    if (opts.approver) {
+      const ok = await opts.approver({ tool: toolName, args: approvalArgs, reason });
+      if (!ok) throw new Error(`${toolName}: rejected by approver.`);
+    }
+    const { digest, effects } = await signer.signAndExecute(tx);
+    return { digest, effects, explorerUrl: explorerTxUrl(signer.network, digest) };
+  };
+  const balance = defineTool({
+    name: "sui_balance",
+    description: "Read a Sui coin balance. Defaults to the agent's own address and SUI when omitted. Returns total balance in MIST plus the coin count.",
+    parameters: z4.object({
+      address: z4.string().optional().describe("Owner address (default: the agent's address)."),
+      coinType: z4.string().optional().describe("Coin type, e.g. 0x2::sui::SUI (default: SUI).")
+    }),
+    execute: async ({ address, coinType }) => {
+      const signer = signerOrThrow();
+      const owner = address ?? signer.address;
+      if (owner === void 0) {
+        throw new Error("sui_balance: no address given and the signer has no key/address.");
+      }
+      const bal = await signer.client.getBalance({ owner, ...coinType ? { coinType } : {} });
+      return {
+        owner,
+        coinType: bal.coinType,
+        totalBalanceMist: bal.totalBalance,
+        coins: bal.coinObjectCount
+      };
+    }
+  });
+  const object = defineTool({
+    name: "sui_object",
+    description: "Read a Sui object's type and fields by id.",
+    parameters: z4.object({ objectId: z4.string().min(1).describe("The object id (0x\u2026).") }),
+    execute: async ({ objectId }) => {
+      const signer = signerOrThrow();
+      const res = await signer.client.getObject({
+        id: objectId,
+        options: { showContent: true, showType: true, showOwner: true }
+      });
+      if (!res.data) throw new Error(`sui_object: ${objectId} not found`);
+      const content = res.data.content;
+      return {
+        objectId,
+        type: res.data.type,
+        fields: content?.dataType === "moveObject" ? content.fields : void 0
+      };
+    }
+  });
+  const executePtb = defineTool({
+    name: "sui_execute_ptb",
+    description: "Sign and submit an unsigned Sui programmable transaction (PTB) that a builder/MCP produced. Re-simulates the PTB, applies the soft policy and approval gate, then signs + submits. Pass the builder's `unsignedPtb` (base64 of the serialized transaction) \u2014 built with NO sender and NO gas (the signer fills both). On-chain caps may still abort it.",
+    sensitive: true,
+    parameters: z4.object({
+      unsignedPtb: z4.string().min(1).describe("The builder's unsigned PTB \u2014 base64 of a serialized Sui transaction.")
+    }),
+    execute: async ({ unsignedPtb }) => {
+      const tx = Transaction2.from(Buffer.from(unsignedPtb, "base64").toString("utf8"));
+      return await executeTx(tx, "sui_execute_ptb", { unsignedPtb }, "sign and submit a Sui PTB");
+    }
+  });
+  const transfer = defineTool({
+    name: "sui_transfer",
+    description: "Build, sign, and submit a coin transfer: send an amount of SUI (or any coin type) to an address. Amounts are in MIST (1 SUI = 1,000,000,000 MIST). Use this for simple sends.",
+    sensitive: true,
+    parameters: z4.object({
+      recipient: z4.string().min(1).describe("Destination address (0x\u2026)."),
+      amountMist: z4.string().min(1).describe('Amount in MIST. e.g. "1000000000" = 1 SUI.'),
+      coinType: z4.string().optional().describe("Coin type (default 0x2::sui::SUI).")
+    }),
+    execute: async ({ recipient, amountMist, coinType }) => {
+      const signer = signerOrThrow();
+      const amount = BigInt(amountMist);
+      const type = coinType ?? "0x2::sui::SUI";
+      const tx = new Transaction2();
+      if (type.endsWith("::sui::SUI")) {
+        const [coin] = tx.splitCoins(tx.gas, [tx.pure.u64(amount)]);
+        tx.transferObjects([coin], tx.pure.address(recipient));
+      } else {
+        const owner = signer.address;
+        if (owner === void 0) throw new Error("sui_transfer: signer has no address.");
+        const { data } = await signer.client.getCoins({ owner, coinType: type });
+        const [first, ...rest] = data;
+        if (!first) throw new Error(`sui_transfer: no ${type} coins owned by ${owner}.`);
+        const primary = tx.object(first.coinObjectId);
+        if (rest.length > 0) {
+          tx.mergeCoins(primary, rest.map((c) => tx.object(c.coinObjectId)));
+        }
+        const [coin] = tx.splitCoins(primary, [tx.pure.u64(amount)]);
+        tx.transferObjects([coin], tx.pure.address(recipient));
+      }
+      return executeTx(
+        tx,
+        "sui_transfer",
+        { recipient, amountMist, coinType: type },
+        `transfer ${amountMist} MIST of ${type} to ${recipient}`
+      );
+    }
+  });
+  const moveCall = defineTool({
+    name: "sui_move_call",
+    description: "Build, sign, and submit ANY Sui Move call \u2014 invoke a function on any package/module. This is the general way to run any on-chain action (swaps, mints, staking, arbitrary contracts). Provide the exact target, type arguments, and ordered arguments.",
+    sensitive: true,
+    parameters: z4.object({
+      target: z4.string().regex(/^0x[0-9a-fA-F]+::[^:]+::[^:]+$/, "must be package::module::function").describe("Fully-qualified function, e.g. 0x2::coin::value."),
+      typeArguments: z4.array(z4.string()).optional().describe('Generic type args, e.g. ["0x2::sui::SUI"].'),
+      args: z4.array(
+        z4.object({
+          kind: z4.enum(["pure", "object", "gas"]).describe("pure value, object id, or the gas coin"),
+          value: z4.string().optional().describe("object: the 0x\u2026 id; pure: the value as a string"),
+          type: z4.string().optional().describe("pure type: u8|u16|u32|u64|u128|u256|bool|address|string (default string)")
+        })
+      ).optional().describe("Ordered arguments to the function.")
+    }),
+    execute: async ({ target, typeArguments, args }) => {
+      const tx = new Transaction2();
+      const built = (args ?? []).map((a) => {
+        if (a.kind === "gas") return tx.gas;
+        if (a.kind === "object") {
+          if (a.value === void 0) throw new Error("sui_move_call: object arg needs `value` (id).");
+          return tx.object(a.value);
+        }
+        const v = a.value ?? "";
+        switch (a.type) {
+          case "u8":
+            return tx.pure.u8(Number(v));
+          case "u16":
+            return tx.pure.u16(Number(v));
+          case "u32":
+            return tx.pure.u32(Number(v));
+          case "u64":
+            return tx.pure.u64(BigInt(v));
+          case "u128":
+            return tx.pure.u128(BigInt(v));
+          case "u256":
+            return tx.pure.u256(BigInt(v));
+          case "bool":
+            return tx.pure.bool(v === "true");
+          case "address":
+            return tx.pure.address(v);
+          default:
+            return tx.pure.string(v);
+        }
+      });
+      tx.moveCall({ target, typeArguments: typeArguments ?? [], arguments: built });
+      return await executeTx(tx, "sui_move_call", { target, typeArguments, args }, `Move call ${target}`);
+    }
+  });
+  return { name: "sui", tools: [balance, object, executePtb, transfer, moveCall] };
+}
+
+// ../../packages/adapters/mcp/src/index.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// ../../packages/adapters/mcp/src/schema.ts
+import { z as z5 } from "zod";
+function jsonSchemaToZod(schema) {
+  if (!schema?.type) return z5.unknown();
+  switch (schema.type) {
+    case "string":
+      return schema.enum ? z5.enum(schema.enum) : z5.string();
+    case "number":
+    case "integer":
+      return z5.number();
+    case "boolean":
+      return z5.boolean();
+    case "array":
+      return z5.array(jsonSchemaToZod(schema.items));
+    case "object": {
+      const required = new Set(schema.required ?? []);
+      const shape = {};
+      for (const [key, prop] of Object.entries(schema.properties ?? {})) {
+        const fieldSchema = jsonSchemaToZod(prop);
+        shape[key] = required.has(key) ? fieldSchema : fieldSchema.optional();
+      }
+      return z5.object(shape).passthrough();
+    }
+    default:
+      return z5.unknown();
+  }
+}
+
+// ../../packages/adapters/mcp/src/index.ts
+async function buildMcpPlugin(transport, prefix) {
+  const client = new Client({ name: "thiny", version: "0.1.0" }, { capabilities: {} });
+  await client.connect(transport);
+  const listed = await client.listTools();
+  const tools = listed.tools.map(
+    (toolDef) => defineTool({
+      name: `${prefix}_${toolDef.name}`,
+      description: toolDef.description ?? toolDef.name,
+      parameters: jsonSchemaToZod(toolDef.inputSchema),
+      execute: async (args) => {
+        const result = await client.callTool({
+          name: toolDef.name,
+          arguments: args ?? {}
+        });
+        return result.content;
+      }
+    })
+  );
+  return {
+    name: `mcp:${prefix}`,
+    tools,
+    async close() {
+      await client.close();
+    }
+  };
+}
+async function mcpHttpPlugin(opts) {
+  const transport = new StreamableHTTPClientTransport(
+    new URL(opts.url),
+    opts.headers ? { requestInit: { headers: opts.headers } } : void 0
+  );
+  return buildMcpPlugin(transport, opts.name ?? "mcp");
+}
+
 // ../../packages/skills/src/catalog.ts
 var BUILTIN_SKILLS = [
   {
@@ -1446,6 +1744,157 @@ var SkillRegistry = class {
 // ../../packages/skills/src/index.ts
 var defaultRegistry = new SkillRegistry();
 
+// src/onboarding.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import * as p from "@clack/prompts";
+var THINY_DIR = join(homedir(), ".thiny");
+var CONFIG = join(THINY_DIR, "config.json");
+function version() {
+  try {
+    const pkg = join(dirname2(fileURLToPath(import.meta.url)), "../package.json");
+    return JSON.parse(readFileSync2(pkg, "utf8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function loadConfig() {
+  return existsSync2(CONFIG) ? JSON.parse(readFileSync2(CONFIG, "utf8")) : null;
+}
+function saveConfig(cfg) {
+  mkdirSync(THINY_DIR, { recursive: true });
+  chmodSync(THINY_DIR, 448);
+  writeFileSync(CONFIG, JSON.stringify(cfg, null, 2));
+  chmodSync(CONFIG, 384);
+}
+function applyConfig(cfg) {
+  if (!cfg) return;
+  const set = (k, v) => {
+    if (v && !process.env[k]) process.env[k] = v;
+  };
+  set("THINY_MODEL", cfg.model);
+  if (cfg.apiKey) {
+    set(cfg.model?.startsWith("anthropic") ? "THINY_ANTHROPIC_API_KEY" : "THINY_OPENAI_API_KEY", cfg.apiKey);
+  }
+  set("THINY_OPENAI_BASE_URL", cfg.baseUrl);
+  set("THINY_PERSONA_NAME", cfg.agentName);
+  set("THINY_USER_ID", cfg.userId);
+  if (cfg.sui?.network) {
+    set("SUI_NETWORK", cfg.sui.network);
+    if (cfg.sui.network === "mainnet") set("SUI_ALLOW_MAINNET", "1");
+  }
+  const sk = cfg.sui?.wallet.secretKey;
+  if (sk) {
+    set("SUI_SECRET_KEY", sk);
+    set("THINY_SUI_SECRET_KEY", sk);
+  }
+  set("MCP_URL", cfg.sui?.rillMcpUrl);
+}
+function bail(v) {
+  if (p.isCancel(v)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return v;
+}
+var MODELS = [
+  { value: "oai-mini", label: "OpenAI \xB7 gpt-4o-mini", hint: "fast, cheap", model: "openai:gpt-4o-mini", needsKey: true },
+  { value: "oai-4o", label: "OpenAI \xB7 gpt-4o", model: "openai:gpt-4o", needsKey: true },
+  { value: "claude-haiku", label: "Anthropic \xB7 claude-haiku-4-5", model: "anthropic:claude-haiku-4-5-20251001", needsKey: true },
+  { value: "claude-sonnet", label: "Anthropic \xB7 claude-sonnet-4-6", model: "anthropic:claude-sonnet-4-6", needsKey: true },
+  { value: "ollama", label: "Ollama", hint: "local, no key", model: "llama3", baseUrl: "http://localhost:11434/v1", apiKey: "ollama" },
+  { value: "custom", label: "Custom", hint: "any OpenAI-compatible endpoint", custom: true }
+];
+async function baseSetup() {
+  p.intro(`Thiny ${version()} \u2014 setup`);
+  const agentName = bail(
+    await p.text({ message: "Agent name", placeholder: "ThinyAI", defaultValue: "ThinyAI" })
+  );
+  const choice = bail(
+    await p.select({ message: "Pick a model", options: MODELS.map(({ value, label, hint }) => ({ value, label, hint })) })
+  );
+  const pick = MODELS.find((m) => m.value === choice) ?? MODELS[0];
+  const cfg = { agentName, userId: "default" };
+  if (pick.custom) {
+    cfg.model = bail(
+      await p.text({ message: "Model id", placeholder: "e.g. MiniMax-M3", validate: (v) => v ? void 0 : "Required" })
+    );
+    cfg.baseUrl = bail(
+      await p.text({
+        message: "Base URL (OpenAI-compatible)",
+        placeholder: "https://api.example.com/v1",
+        validate: (v) => /^https?:\/\//.test(v) ? void 0 : "Must start with http(s)://"
+      })
+    );
+    cfg.apiKey = bail(await p.password({ message: "API key" }));
+  } else {
+    cfg.model = pick.model;
+    if (pick.baseUrl) cfg.baseUrl = pick.baseUrl;
+    cfg.apiKey = pick.apiKey ?? (pick.needsKey ? bail(await p.password({ message: "API key" })) : void 0);
+  }
+  saveConfig(cfg);
+  p.outro(`Saved ${CONFIG} \u2014 run \`thiny\` to start, or \`thiny sui init\` for Sui.`);
+  return cfg;
+}
+async function suiInit() {
+  let cfg = loadConfig();
+  cfg ??= await baseSetup();
+  p.intro("Thiny \u2014 Sui setup");
+  const network = bail(
+    await p.select({
+      message: "Sui network (you can change this later)",
+      options: [
+        { value: "testnet", label: "Testnet", hint: "recommended for testing" },
+        { value: "mainnet", label: "Mainnet", hint: "real funds" }
+      ]
+    })
+  );
+  const choice = bail(
+    await p.select({
+      message: "Wallet",
+      options: [
+        { value: "paste", label: "Paste an existing private key", hint: "suiprivkey\u2026" },
+        { value: "generate", label: "Generate a new key pair locally" },
+        { value: "rill", label: "Agent wallet with on-chain capabilities", hint: "Rill" }
+      ]
+    })
+  );
+  const { Ed25519Keypair: Ed25519Keypair2 } = await import("@mysten/sui/keypairs/ed25519");
+  let wallet;
+  let address;
+  if (choice === "generate" || choice === "rill") {
+    const kp = Ed25519Keypair2.generate();
+    wallet = { type: "generated", secretKey: kp.getSecretKey() };
+    address = kp.getPublicKey().toSuiAddress();
+  } else {
+    const sk = bail(
+      await p.password({
+        message: "Private key (suiprivkey\u2026)",
+        validate: (v) => v.startsWith("suiprivkey") ? void 0 : "Expected a suiprivkey\u2026 string"
+      })
+    );
+    wallet = { type: "imported", secretKey: sk };
+    address = Ed25519Keypair2.fromSecretKey(sk).getPublicKey().toSuiAddress();
+  }
+  cfg.sui = { network, wallet, address };
+  if (choice === "rill") {
+    const url = bail(
+      await p.text({ message: "Rill MCP URL", placeholder: "leave blank to add later", defaultValue: "" })
+    );
+    if (url) cfg.sui.rillMcpUrl = url;
+  }
+  saveConfig(cfg);
+  const faucet = network === "testnet" ? "\nFaucet: https://faucet.sui.io  (or `sui client faucet`)" : "";
+  p.note(`${address}${faucet}`, `\u26A0 Fund this address (${network}) before sending transactions`);
+  p.outro(`Sui configured (${network}).`);
+}
+async function ensureSetup() {
+  if (loadConfig() || process.env.THINY_MODEL) return;
+  await baseSetup();
+}
+
 // src/skills.ts
 async function loadSkills(ids, env = process.env) {
   const { satisfied, warnings } = defaultRegistry.checkEnv(ids, env);
@@ -1779,7 +2228,7 @@ function captureStats(base, turn) {
 var echoTool = defineTool({
   name: "echo",
   description: "Echo text back verbatim. Use when asked to repeat or echo something.",
-  parameters: z4.object({ text: z4.string().describe("the text to echo") }),
+  parameters: z6.object({ text: z6.string().describe("the text to echo") }),
   execute: ({ text: text2 }) => Promise.resolve({ echoed: text2 })
 });
 function parseSkillArgs() {
@@ -1790,10 +2239,10 @@ function parseSkillArgs() {
 }
 var currentSessionId = `cli-${(/* @__PURE__ */ new Date()).getTime().toString()}`;
 async function runCli() {
-  const thinyDir = join(homedir(), ".thiny");
-  mkdirSync(thinyDir, { recursive: true });
+  const thinyDir = join2(homedir2(), ".thiny");
+  mkdirSync2(thinyDir, { recursive: true });
   const envLogFile = process.env.THINY_LOG_FILE?.trim();
-  const logFile = envLogFile && envLogFile.length > 0 ? envLogFile : join(thinyDir, "cli.log");
+  const logFile = envLogFile && envLogFile.length > 0 ? envLogFile : join2(thinyDir, "cli.log");
   const fileLogger = pinoLogger({ level: process.env.LOG_LEVEL ?? "info", file: logFile });
   const turn = { inputTokens: 0, outputTokens: 0, toolCalls: 0, modelCalls: 0 };
   const session = { inputTokens: 0, outputTokens: 0, toolCalls: 0, turns: 0 };
@@ -1824,7 +2273,7 @@ async function runCli() {
     client: walrus,
     // Stable per-user location (~/.thiny) so cross-session memory works no matter which
     // directory `thiny` is launched from — a cwd-relative file would fragment per folder.
-    pointers: filePointerStore(process.env.WALRUS_POINTERS ?? join(thinyDir, "thiny-pointers.json")),
+    pointers: filePointerStore(process.env.WALRUS_POINTERS ?? join2(thinyDir, "thiny-pointers.json")),
     userId,
     onStoreStart: () => pendingWrites += 1,
     onStore: (ref) => {
@@ -1840,13 +2289,68 @@ async function runCli() {
     process.env
   );
   const persona = process.env.THINY_PERSONA_NAME ? { name: process.env.THINY_PERSONA_NAME, description: process.env.THINY_PERSONA_DESCRIPTION } : void 0;
+  const allowMainnet = process.env.SUI_ALLOW_MAINNET === "1";
+  const suiNetwork = process.env.SUI_NETWORK === "mainnet" ? "mainnet" : "testnet";
+  const suiKey0 = process.env.SUI_SECRET_KEY ?? process.env.THINY_SUI_SECRET_KEY;
+  let suiSignerRef = suiKey0 ? suiSigner({ network: suiNetwork, secretKey: suiKey0, allowMainnet }) : null;
+  const suiPlugins = [];
+  if (process.env.MCP_URL) {
+    try {
+      suiPlugins.push(await mcpHttpPlugin({ url: process.env.MCP_URL, name: "rill" }));
+    } catch (err) {
+      renderWarning(`Rill MCP unavailable: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const suiSetupTool = defineTool({
+    name: "sui_setup",
+    description: "Set up or change the agent's Sui wallet so it can read balances and sign transactions. Use when the user asks to enable Sui, create/import a wallet, or switch network. Modes: generate (new local key), import (a suiprivkey\u2026), rill (use a Rill MCP signer URL). Takes effect immediately; Rill's builder tools connect on the next start. Always remind the user to fund the returned address.",
+    sensitive: true,
+    parameters: z6.object({
+      network: z6.enum(["testnet", "mainnet"]).default("testnet"),
+      wallet: z6.enum(["generate", "import", "rill"]).describe("generate a new key, import a suiprivkey\u2026, or use a Rill MCP signer"),
+      secretKey: z6.string().optional().describe("suiprivkey\u2026 \u2014 required when wallet=import"),
+      rillMcpUrl: z6.string().optional().describe("Rill MCP URL \u2014 used when wallet=rill")
+    }),
+    execute: async ({ network: net, wallet, secretKey, rillMcpUrl }) => {
+      const network2 = net === "mainnet" ? "mainnet" : "testnet";
+      const { Ed25519Keypair: Ed25519Keypair2 } = await import("@mysten/sui/keypairs/ed25519");
+      let sk;
+      let address;
+      if (wallet === "import") {
+        if (!secretKey?.startsWith("suiprivkey")) {
+          throw new Error("sui_setup: import requires a `secretKey` starting with suiprivkey\u2026");
+        }
+        sk = secretKey;
+        address = Ed25519Keypair2.fromSecretKey(sk).getPublicKey().toSuiAddress();
+      } else {
+        const kp = Ed25519Keypair2.generate();
+        sk = kp.getSecretKey();
+        address = kp.getPublicKey().toSuiAddress();
+      }
+      const cfg = loadConfig() ?? {};
+      cfg.sui = {
+        network: network2,
+        address,
+        wallet: { type: wallet === "import" ? "imported" : "generated", secretKey: sk }
+      };
+      if (wallet === "rill" && rillMcpUrl) cfg.sui.rillMcpUrl = rillMcpUrl;
+      saveConfig(cfg);
+      suiSignerRef = suiSigner({ network: network2, secretKey: sk, allowMainnet });
+      return {
+        ok: true,
+        network: network2,
+        address,
+        note: `Sui wallet ready on ${network2} at ${address}. The user MUST fund this address before sending transactions` + (network2 === "testnet" ? " (faucet: https://faucet.sui.io)." : ".") + (wallet === "rill" ? " Rill MCP URL saved \u2014 restart thiny to connect its builder tools." : "")
+      };
+    }
+  });
   const budget = budgetMiddleware({ maxCalls: 50, logger });
   const agent = await createAgent({
     model,
     logger: agentLogger,
     persona,
-    systemPrompt: "You are a helpful AI assistant. Use tools when they help you answer better. Be concise.\n\nMEMORY: You have persistent long-term memory across sessions, stored on Walrus. What you already know about the user is injected automatically at the start of each conversation under \u201C[User Memory \u2026]\u201D. When the user shares anything durable about themselves \u2014 their name, role, preferences, projects, or goals, even casually \u2014 immediately call remember_fact to save it. If asked what you remember, answer from the injected user memory (or call recall_memory). You DO remember across sessions \u2014 never say you lack memory or that each session starts fresh.\n\nFor multi-step work, call update_plan to track steps and delegate_task to hand focused sub-problems to a sub-agent.",
-    tools: [echoTool],
+    systemPrompt: "You are a helpful AI assistant. Use tools when they help you answer better. Be concise.\n\nMEMORY: You have persistent long-term memory across sessions, stored on Walrus. What you already know about the user is injected automatically at the start of each conversation under \u201C[User Memory \u2026]\u201D. When the user shares anything durable about themselves \u2014 their name, role, preferences, projects, or goals, even casually \u2014 immediately call remember_fact to save it. If asked what you remember, answer from the injected user memory (or call recall_memory). You DO remember across sessions \u2014 never say you lack memory or that each session starts fresh.\n\nFor multi-step work, call update_plan to track steps and delegate_task to hand focused sub-problems to a sub-agent.\n\nSUI: You can operate on the Sui blockchain. " + (suiSignerRef ? `A wallet is configured on ${suiNetwork} at ${suiSignerRef.address ?? "(unknown)"}. ` : "No wallet is set up yet \u2014 when the user wants Sui, call sui_setup (generate / import / rill) to create or connect one, then tell them to fund the returned address. ") + "Use sui_balance to read balances and sui_object to inspect objects. To SEND a transaction you need an UNSIGNED PTB built by a builder (e.g. a connected Rill MCP tool); pass it to sui_execute_ptb, which simulates, applies caps, and signs. Never claim you cannot use Sui \u2014 you can.",
+    tools: [echoTool, suiSetupTool],
     plugins: [
       {
         name: "observability",
@@ -1855,6 +2359,10 @@ async function runCli() {
       },
       agentsPlugin(),
       memoryPlugin,
+      suiPlugin({ signer: () => suiSignerRef }),
+      // always present; tools guide setup if no wallet
+      ...suiPlugins,
+      // Rill MCP builder tools (if connected)
       ...skillPlugins
     ]
   });
@@ -1895,6 +2403,11 @@ async function runCli() {
   );
   if (walrusAudit)
     renderInfo(`Walrus audit: ON (${network}) \u2014 each turn's action log is stored + verifiable`);
+  if (suiSignerRef)
+    renderInfo(
+      `Sui: ${suiNetwork} \xB7 ${suiSignerRef.address ?? "?"}${process.env.MCP_URL ? " \xB7 Rill MCP connected" : ""}`
+    );
+  else renderInfo("Sui: no wallet \u2014 ask the agent to set one up, or run `thiny sui init`");
   const rl = createInterface({ input: stdin, output: stdout });
   emitKeypressEvents(stdin);
   const spinner = new Spinner();
@@ -2104,157 +2617,6 @@ Audit trail ${blobId}
   }
 }
 
-// src/onboarding.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, chmodSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2, dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
-import * as p from "@clack/prompts";
-var THINY_DIR = join2(homedir2(), ".thiny");
-var CONFIG = join2(THINY_DIR, "config.json");
-function version() {
-  try {
-    const pkg = join2(dirname2(fileURLToPath(import.meta.url)), "../package.json");
-    return JSON.parse(readFileSync2(pkg, "utf8")).version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-function loadConfig() {
-  return existsSync2(CONFIG) ? JSON.parse(readFileSync2(CONFIG, "utf8")) : null;
-}
-function saveConfig(cfg) {
-  mkdirSync2(THINY_DIR, { recursive: true });
-  chmodSync(THINY_DIR, 448);
-  writeFileSync(CONFIG, JSON.stringify(cfg, null, 2));
-  chmodSync(CONFIG, 384);
-}
-function applyConfig(cfg) {
-  if (!cfg) return;
-  const set = (k, v) => {
-    if (v && !process.env[k]) process.env[k] = v;
-  };
-  set("THINY_MODEL", cfg.model);
-  if (cfg.apiKey) {
-    set(cfg.model?.startsWith("anthropic") ? "THINY_ANTHROPIC_API_KEY" : "THINY_OPENAI_API_KEY", cfg.apiKey);
-  }
-  set("THINY_OPENAI_BASE_URL", cfg.baseUrl);
-  set("THINY_PERSONA_NAME", cfg.agentName);
-  set("THINY_USER_ID", cfg.userId);
-  if (cfg.sui?.network) {
-    set("SUI_NETWORK", cfg.sui.network);
-    if (cfg.sui.network === "mainnet") set("SUI_ALLOW_MAINNET", "1");
-  }
-  const sk = cfg.sui?.wallet.secretKey;
-  if (sk) {
-    set("SUI_SECRET_KEY", sk);
-    set("THINY_SUI_SECRET_KEY", sk);
-  }
-  set("MCP_URL", cfg.sui?.rillMcpUrl);
-}
-function bail(v) {
-  if (p.isCancel(v)) {
-    p.cancel("Cancelled.");
-    process.exit(0);
-  }
-  return v;
-}
-var MODELS = [
-  { value: "oai-mini", label: "OpenAI \xB7 gpt-4o-mini", hint: "fast, cheap", model: "openai:gpt-4o-mini", needsKey: true },
-  { value: "oai-4o", label: "OpenAI \xB7 gpt-4o", model: "openai:gpt-4o", needsKey: true },
-  { value: "claude-haiku", label: "Anthropic \xB7 claude-haiku-4-5", model: "anthropic:claude-haiku-4-5-20251001", needsKey: true },
-  { value: "claude-sonnet", label: "Anthropic \xB7 claude-sonnet-4-6", model: "anthropic:claude-sonnet-4-6", needsKey: true },
-  { value: "ollama", label: "Ollama", hint: "local, no key", model: "llama3", baseUrl: "http://localhost:11434/v1", apiKey: "ollama" },
-  { value: "custom", label: "Custom", hint: "any OpenAI-compatible endpoint", custom: true }
-];
-async function baseSetup() {
-  p.intro(`Thiny ${version()} \u2014 setup`);
-  const agentName = bail(
-    await p.text({ message: "Agent name", placeholder: "ThinyAI", defaultValue: "ThinyAI" })
-  );
-  const choice = bail(
-    await p.select({ message: "Pick a model", options: MODELS.map(({ value, label, hint }) => ({ value, label, hint })) })
-  );
-  const pick = MODELS.find((m) => m.value === choice) ?? MODELS[0];
-  const cfg = { agentName, userId: "default" };
-  if (pick.custom) {
-    cfg.model = bail(
-      await p.text({ message: "Model id", placeholder: "e.g. MiniMax-M3", validate: (v) => v ? void 0 : "Required" })
-    );
-    cfg.baseUrl = bail(
-      await p.text({
-        message: "Base URL (OpenAI-compatible)",
-        placeholder: "https://api.example.com/v1",
-        validate: (v) => /^https?:\/\//.test(v) ? void 0 : "Must start with http(s)://"
-      })
-    );
-    cfg.apiKey = bail(await p.password({ message: "API key" }));
-  } else {
-    cfg.model = pick.model;
-    if (pick.baseUrl) cfg.baseUrl = pick.baseUrl;
-    cfg.apiKey = pick.apiKey ?? (pick.needsKey ? bail(await p.password({ message: "API key" })) : void 0);
-  }
-  saveConfig(cfg);
-  p.outro(`Saved ${CONFIG} \u2014 run \`thiny\` to start, or \`thiny sui init\` for Sui.`);
-  return cfg;
-}
-async function suiInit() {
-  let cfg = loadConfig();
-  cfg ??= await baseSetup();
-  p.intro("Thiny \u2014 Sui setup");
-  const network = bail(
-    await p.select({
-      message: "Sui network (you can change this later)",
-      options: [
-        { value: "testnet", label: "Testnet", hint: "recommended for testing" },
-        { value: "mainnet", label: "Mainnet", hint: "real funds" }
-      ]
-    })
-  );
-  const choice = bail(
-    await p.select({
-      message: "Wallet",
-      options: [
-        { value: "paste", label: "Paste an existing private key", hint: "suiprivkey\u2026" },
-        { value: "generate", label: "Generate a new key pair locally" },
-        { value: "rill", label: "Agent wallet with on-chain capabilities", hint: "Rill" }
-      ]
-    })
-  );
-  const { Ed25519Keypair } = await import("@mysten/sui/keypairs/ed25519");
-  let wallet;
-  let address;
-  if (choice === "generate" || choice === "rill") {
-    const kp = Ed25519Keypair.generate();
-    wallet = { type: "generated", secretKey: kp.getSecretKey() };
-    address = kp.getPublicKey().toSuiAddress();
-  } else {
-    const sk = bail(
-      await p.password({
-        message: "Private key (suiprivkey\u2026)",
-        validate: (v) => v.startsWith("suiprivkey") ? void 0 : "Expected a suiprivkey\u2026 string"
-      })
-    );
-    wallet = { type: "imported", secretKey: sk };
-    address = Ed25519Keypair.fromSecretKey(sk).getPublicKey().toSuiAddress();
-  }
-  cfg.sui = { network, wallet, address };
-  if (choice === "rill") {
-    const url = bail(
-      await p.text({ message: "Rill MCP URL", placeholder: "leave blank to add later", defaultValue: "" })
-    );
-    if (url) cfg.sui.rillMcpUrl = url;
-  }
-  saveConfig(cfg);
-  const faucet = network === "testnet" ? "\nFaucet: https://faucet.sui.io  (or `sui client faucet`)" : "";
-  p.note(`${address}${faucet}`, `\u26A0 Fund this address (${network}) before sending transactions`);
-  p.outro(`Sui configured (${network}).`);
-}
-async function ensureSetup() {
-  if (loadConfig() || process.env.THINY_MODEL) return;
-  await baseSetup();
-}
-
 // src/bin.ts
 function help() {
   console.log(`thiny ${version()}
@@ -2263,11 +2625,33 @@ Usage:
   thiny                 Start the interactive CLI agent (runs setup on first use)
   thiny init            Re-run setup (model, agent name, key)
   thiny sui init        Add Sui capabilities (network + wallet)
+  thiny update          Update thinyai to the latest version
   thiny --version       Print version
   thiny help            Show this help
 
 Config: ~/.thiny/config.json  (no .env needed)`);
 }
+function detectPackageManager() {
+  const here = fileURLToPath2(import.meta.url);
+  if (here.includes("/.bun/") || here.includes("\\.bun\\")) return "bun";
+  if (here.includes("pnpm")) return "pnpm";
+  return "npm";
+}
+function update() {
+  const pm = detectPackageManager();
+  const args = pm === "npm" ? ["install", "-g", "thinyai@latest"] : ["add", "-g", "thinyai@latest"];
+  console.log(`Updating thinyai via ${pm}\u2026  (${pm} ${args.join(" ")})`);
+  const res = spawnSync(pm, args, { stdio: "inherit" });
+  if (res.status !== 0) {
+    console.error(
+      `
+Update failed. Run it manually:  ${pm} ${args.join(" ")}
+(or, if you used a different installer:  npm i -g thinyai@latest)`
+    );
+    process.exit(res.status ?? 1);
+  }
+  console.log("\n\u2713 Updated. Run `thiny --version` to confirm.");
+}
 async function run() {
   const [sub, sub2] = process.argv.slice(2);
   switch (sub) {
@@ -2278,6 +2662,10 @@ async function run() {
       if (sub2 === "init") await suiInit();
       else console.log("Usage: thiny sui init");
       return;
+    case "update":
+    case "upgrade":
+      update();
+      return;
     case "--version":
     case "-v":
       console.log(version());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinyai",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Thiny AI — a beautiful terminal agent: interactive chat, tools, Walrus memory, and Sui execution.",
   "type": "module",
   "license": "MIT",
@@ -22,6 +22,7 @@
     "@ai-sdk/anthropic": "^1.0.0",
     "@ai-sdk/openai": "^1.3.0",
     "@clack/prompts": "^1.6.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
     "@mysten/sui": "^2.19.0",
     "ai": "^4.0.0",
     "chalk": "^5.3.0",
@@ -36,14 +37,16 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^5.5.0",
-    "@thiny/logger-pino": "0.1.0",
-    "@thiny/model-aisdk": "0.1.0",
     "@thiny/core": "0.1.0",
+    "@thiny/model-aisdk": "0.1.0",
+    "@thiny/walrus": "0.1.0",
+    "@thiny/logger-pino": "0.1.0",
     "@thiny/memory-memwal": "0.1.0",
-    "@thiny/mcp": "0.1.0",
-    "@thiny/plugin-agents": "0.1.0",
     "@thiny/skills": "0.1.0",
-    "@thiny/walrus": "0.1.0"
+    "@thiny/plugin-agents": "0.1.0",
+    "@thiny/signer-sui": "0.1.0",
+    "@thiny/plugin-sui": "0.1.0",
+    "@thiny/mcp": "0.1.0"
   },
   "author": "Thiny AI",
   "engines": {