@ethosagent/tools-india-broker-zerodha 0.1.0

package/dist/index.js

@@ -0,0 +1,850 @@
+// src/auth.ts
+import { createHash } from "crypto";
+var KITE_SESSION_URL = "https://api.kite.trade/session/token";
+function buildLoginUrl(apiKey) {
+  return `https://kite.trade/connect/login?v=3&api_key=${apiKey}`;
+}
+function computeChecksum(apiKey, requestToken, apiSecret) {
+  return createHash("sha256").update(apiKey + requestToken + apiSecret).digest("hex");
+}
+async function exchangeToken(apiKey, apiSecret, requestToken) {
+  const checksum = computeChecksum(apiKey, requestToken, apiSecret);
+  const body = new URLSearchParams();
+  body.set("api_key", apiKey);
+  body.set("request_token", requestToken);
+  body.set("checksum", checksum);
+  const res = await fetch(KITE_SESSION_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  const json = await res.json();
+  if (json.status !== "success") {
+    throw new Error(`Token exchange failed: ${json.message ?? "unknown error"}`);
+  }
+  return json.data;
+}
+async function validateToken(apiKey, accessToken) {
+  try {
+    const res = await fetch("https://api.kite.trade/user/profile", {
+      method: "GET",
+      headers: {
+        Authorization: `token ${apiKey}:${accessToken}`,
+        "X-Kite-Version": "3"
+      }
+    });
+    if (res.status === 403) {
+      return { valid: false, expiresHint: "Token expired" };
+    }
+    const json = await res.json();
+    if (json.error_type === "TokenException") {
+      return { valid: false, expiresHint: "Token expired" };
+    }
+    if (json.status === "success" && json.data) {
+      return {
+        valid: true,
+        userId: json.data.user_id,
+        expiresHint: "tonight at midnight IST"
+      };
+    }
+    return { valid: false, expiresHint: "Unknown validation error" };
+  } catch {
+    return { valid: false, expiresHint: "Network error during validation" };
+  }
+}
+
+// src/store.ts
+import Database from "better-sqlite3";
+
+// src/schema.ts
+var SQL_CREATE_HOLDINGS_CACHE = `
+  CREATE TABLE IF NOT EXISTS holdings_cache (
+    symbol        TEXT PRIMARY KEY,
+    exchange      TEXT NOT NULL,
+    isin          TEXT,
+    quantity      INTEGER NOT NULL,
+    t1_quantity   INTEGER NOT NULL DEFAULT 0,
+    avg_price     REAL NOT NULL,
+    ltp           REAL,
+    pnl           REAL,
+    pnl_pct       REAL,
+    day_change    REAL,
+    product       TEXT NOT NULL,
+    refreshed_at  INTEGER NOT NULL
+  ) STRICT;
+`;
+var SQL_CREATE_ORDER_LOG = `
+  CREATE TABLE IF NOT EXISTS order_log (
+    id              TEXT PRIMARY KEY,
+    created_at      INTEGER NOT NULL,
+    symbol          TEXT NOT NULL,
+    exchange        TEXT NOT NULL,
+    transaction_type TEXT NOT NULL,
+    quantity        INTEGER NOT NULL,
+    order_type      TEXT NOT NULL,
+    price           REAL,
+    product         TEXT NOT NULL,
+    dry_run         INTEGER NOT NULL,
+    kite_order_id   TEXT,
+    status          TEXT NOT NULL,
+    rejection_reason TEXT,
+    agent_session   TEXT
+  ) STRICT;
+`;
+var SQL_CREATE_SYNC_META = `
+  CREATE TABLE IF NOT EXISTS sync_meta (
+    key         TEXT PRIMARY KEY,
+    fetched_at  INTEGER NOT NULL,
+    status      TEXT NOT NULL DEFAULT 'ok'
+  ) STRICT;
+`;
+function migrate(db) {
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(SQL_CREATE_HOLDINGS_CACHE);
+  db.exec(SQL_CREATE_ORDER_LOG);
+  db.exec(SQL_CREATE_SYNC_META);
+}
+
+// src/store.ts
+var TTL = {
+  HOLDINGS: 60 * 60 * 1e3
+  // 1 hour
+};
+var ZerodhaStore = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    migrate(this.db);
+  }
+  close() {
+    this.db.close();
+  }
+  // -- Holdings cache --------------------------------------------------------
+  replaceHoldings(holdings) {
+    const now = Date.now();
+    const tx = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM holdings_cache").run();
+      const stmt = this.db.prepare(`
+        INSERT INTO holdings_cache
+          (symbol, exchange, isin, quantity, t1_quantity, avg_price, ltp, pnl, pnl_pct, day_change, product, refreshed_at)
+        VALUES
+          (@symbol, @exchange, @isin, @quantity, @t1Quantity, @avgPrice, @ltp, @pnl, @pnlPct, @dayChange, @product, @refreshedAt)
+      `);
+      for (const h of holdings) {
+        stmt.run({
+          symbol: h.symbol,
+          exchange: h.exchange,
+          isin: h.isin,
+          quantity: h.quantity,
+          t1Quantity: h.t1Quantity,
+          avgPrice: h.avgPrice,
+          ltp: h.ltp,
+          pnl: h.pnl,
+          pnlPct: h.pnlPct,
+          dayChange: h.dayChange,
+          product: h.product,
+          refreshedAt: h.refreshedAt
+        });
+      }
+      this.db.prepare("INSERT OR REPLACE INTO sync_meta (key, fetched_at, status) VALUES (?, ?, ?)").run("holdings", now, "ok");
+    });
+    tx();
+  }
+  getHoldings() {
+    const rows = this.db.prepare("SELECT * FROM holdings_cache").all();
+    return rows.map((r) => ({
+      symbol: r.symbol,
+      exchange: r.exchange,
+      isin: r.isin,
+      quantity: r.quantity,
+      t1Quantity: r.t1_quantity,
+      avgPrice: r.avg_price,
+      ltp: r.ltp,
+      pnl: r.pnl,
+      pnlPct: r.pnl_pct,
+      dayChange: r.day_change,
+      product: r.product,
+      refreshedAt: r.refreshed_at
+    }));
+  }
+  isStale(key, ttlMs) {
+    const row = this.db.prepare("SELECT fetched_at FROM sync_meta WHERE key = ?").get(key);
+    if (!row) return true;
+    return Date.now() - row.fetched_at > ttlMs;
+  }
+  getLastFetchedAt(key) {
+    const row = this.db.prepare("SELECT fetched_at FROM sync_meta WHERE key = ?").get(key);
+    return row?.fetched_at ?? 0;
+  }
+  setSyncMeta(key, status = "ok") {
+    this.db.prepare("INSERT OR REPLACE INTO sync_meta (key, fetched_at, status) VALUES (?, ?, ?)").run(key, Date.now(), status);
+  }
+  // -- Order audit log -------------------------------------------------------
+  logOrder(row) {
+    this.db.prepare(
+      `INSERT INTO order_log
+          (id, created_at, symbol, exchange, transaction_type, quantity, order_type, price, product, dry_run, kite_order_id, status, rejection_reason, agent_session)
+        VALUES
+          (@id, @createdAt, @symbol, @exchange, @transactionType, @quantity, @orderType, @price, @product, @dryRun, @kiteOrderId, @status, @rejectionReason, @agentSession)`
+    ).run({
+      id: row.id,
+      createdAt: row.createdAt,
+      symbol: row.symbol,
+      exchange: row.exchange,
+      transactionType: row.transaction,
+      quantity: row.quantity,
+      orderType: row.orderType,
+      price: row.price,
+      product: row.product,
+      dryRun: row.dryRun ? 1 : 0,
+      kiteOrderId: row.kiteOrderId,
+      status: row.status,
+      rejectionReason: row.rejectionReason,
+      agentSession: row.agentSession
+    });
+  }
+  getOrderLog(limit = 50) {
+    const rows = this.db.prepare("SELECT * FROM order_log ORDER BY created_at DESC LIMIT ?").all(limit);
+    return rows.map((r) => ({
+      id: r.id,
+      createdAt: r.created_at,
+      symbol: r.symbol,
+      exchange: r.exchange,
+      transaction: r.transaction_type,
+      quantity: r.quantity,
+      orderType: r.order_type,
+      price: r.price,
+      product: r.product,
+      dryRun: r.dry_run === 1,
+      kiteOrderId: r.kite_order_id,
+      status: r.status,
+      rejectionReason: r.rejection_reason,
+      agentSession: r.agent_session
+    }));
+  }
+  clean() {
+    this.db.prepare("DELETE FROM holdings_cache").run();
+    this.db.prepare("DELETE FROM order_log").run();
+    this.db.prepare("DELETE FROM sync_meta").run();
+    return { tablesCleared: ["holdings_cache", "order_log", "sync_meta"] };
+  }
+};
+
+// src/tools.ts
+import { randomUUID } from "crypto";
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { defineTool, err, ok } from "@ethosagent/plugin-sdk/tool-helpers";
+
+// src/kite-client.ts
+var KITE_BASE = "https://api.kite.trade";
+function authHeaders(creds) {
+  return {
+    Authorization: `token ${creds.apiKey}:${creds.accessToken}`,
+    "X-Kite-Version": "3",
+    "Content-Type": "application/x-www-form-urlencoded"
+  };
+}
+var KiteTokenExpiredError = class extends Error {
+  code = "TOKEN_EXPIRED";
+  constructor(message = "Kite access token expired. Renew via zerodha-broker auth.") {
+    super(message);
+    this.name = "KiteTokenExpiredError";
+  }
+};
+var KiteApiError = class extends Error {
+  constructor(message, errorType, statusCode) {
+    super(message);
+    this.errorType = errorType;
+    this.statusCode = statusCode;
+    this.name = "KiteApiError";
+  }
+  errorType;
+  statusCode;
+};
+async function kiteGet(creds, path) {
+  const res = await fetch(`${KITE_BASE}${path}`, {
+    method: "GET",
+    headers: authHeaders(creds)
+  });
+  const body = await res.json();
+  if (res.status === 403 || body.error_type === "TokenException") {
+    throw new KiteTokenExpiredError(body.message);
+  }
+  if (body.status === "error") {
+    throw new KiteApiError(
+      body.message ?? "Unknown error",
+      body.error_type ?? "Unknown",
+      res.status
+    );
+  }
+  return body.data;
+}
+async function fetchMargins(creds) {
+  return kiteGet(creds, "/user/margins");
+}
+async function fetchHoldings(creds) {
+  return kiteGet(creds, "/portfolio/holdings");
+}
+async function fetchPositions(creds) {
+  return kiteGet(creds, "/portfolio/positions");
+}
+async function fetchOrders(creds) {
+  return kiteGet(creds, "/orders");
+}
+async function placeOrder(creds, params) {
+  const variety = params.variety ?? "regular";
+  const body = new URLSearchParams();
+  body.set("exchange", params.exchange);
+  body.set("tradingsymbol", params.tradingsymbol);
+  body.set("transaction_type", params.transaction_type);
+  body.set("quantity", String(params.quantity));
+  body.set("order_type", params.order_type);
+  body.set("product", params.product);
+  body.set("validity", params.validity ?? "DAY");
+  if (params.price != null) body.set("price", String(params.price));
+  if (params.trigger_price != null) body.set("trigger_price", String(params.trigger_price));
+  const res = await fetch(`${KITE_BASE}/orders/${variety}`, {
+    method: "POST",
+    headers: authHeaders(creds),
+    body: body.toString()
+  });
+  const json = await res.json();
+  if (res.status === 403 || json.error_type === "TokenException") {
+    throw new KiteTokenExpiredError(json.message);
+  }
+  if (json.status === "error") {
+    throw new KiteApiError(
+      json.message ?? "Order placement failed",
+      json.error_type ?? "Unknown",
+      res.status
+    );
+  }
+  return json.data;
+}
+
+// src/tools.ts
+async function getCredentials(ctx) {
+  const apiKey = await ctx.secretsResolver?.get("brokers/zerodha/apiKey");
+  const accessToken = await ctx.secretsResolver?.get("brokers/zerodha/accessToken");
+  if (!apiKey || !accessToken) {
+    return err(
+      "Zerodha credentials not configured. Store api_key and access_token in ~/.ethos/secrets/brokers/zerodha/",
+      "not_available"
+    );
+  }
+  return { apiKey, accessToken };
+}
+function isToolResult(v) {
+  return typeof v === "object" && v !== null && "ok" in v;
+}
+function tokenExpiredResult(apiKey) {
+  const loginUrl = apiKey ? buildLoginUrl(apiKey) : "https://kite.trade/connect/login?v=3";
+  return err(
+    `Token expired. Renew daily access token:
+1. Open ${loginUrl}
+2. Log in and copy request_token from redirect URL
+3. Run: zerodha-broker auth --request-token TOKEN`,
+    "not_available"
+  );
+}
+function kiteHoldingToRow(h, now) {
+  return {
+    symbol: h.tradingsymbol,
+    exchange: h.exchange,
+    isin: h.isin,
+    quantity: h.quantity,
+    t1Quantity: h.t1_quantity,
+    avgPrice: h.average_price,
+    ltp: h.last_price,
+    pnl: h.pnl,
+    pnlPct: h.average_price > 0 ? Number((h.pnl / (h.quantity * h.average_price) * 100).toFixed(2)) : null,
+    dayChange: h.day_change_percentage,
+    product: h.product,
+    refreshedAt: now
+  };
+}
+function defaultDbPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+  return process.env.ZERODHA_DB ?? `${home}/.ethos/zerodha/zerodha.db`;
+}
+var zerodhaAuthStatus = defineTool({
+  name: "zerodha_auth_status",
+  description: `Check if the Zerodha access token is valid and the account is ready for API calls.
+Always call this first in a session before reading portfolio data.
+Returns whether token is valid, expiry estimate, and account user_id.
+If token is expired, returns instructions for renewal.`,
+  toolset: "broker",
+  maxResultChars: 1e3,
+  capabilities: {
+    network: { allowedHosts: ["api.kite.trade"] },
+    secrets: ["brokers/zerodha/apiKey", "brokers/zerodha/accessToken"]
+  },
+  schema: { type: "object", properties: {} },
+  async execute(_args, ctx) {
+    try {
+      const creds = await getCredentials(ctx);
+      if (isToolResult(creds)) return creds;
+      const result = await validateToken(creds.apiKey, creds.accessToken);
+      if (result.valid) {
+        return ok(
+          JSON.stringify({
+            valid: true,
+            user_id: result.userId,
+            expires_hint: result.expiresHint,
+            warning: null
+          })
+        );
+      }
+      return tokenExpiredResult(creds.apiKey);
+    } catch (e) {
+      if (e instanceof KiteTokenExpiredError) {
+        return tokenExpiredResult();
+      }
+      return err(e instanceof Error ? e.message : String(e));
+    }
+  }
+});
+var zerodhaAuthComplete = defineTool({
+  name: "zerodha_auth_complete",
+  description: `Complete daily Zerodha authentication by exchanging a request_token for an access_token.
+Call this after the user has opened the Zerodha login URL and been redirected back with a request_token.
+The request_token appears in the redirect URL as ?request_token=YYY.
+Exchanges it for a fresh access_token and stores it in ~/.ethos/secrets/brokers/zerodha/accessToken.
+The new token is valid until midnight IST.`,
+  toolset: "broker",
+  maxResultChars: 500,
+  capabilities: {
+    network: { allowedHosts: ["api.kite.trade"] },
+    secrets: ["brokers/zerodha/apiKey", "brokers/zerodha/apiSecret"]
+  },
+  schema: {
+    type: "object",
+    properties: {
+      request_token: {
+        type: "string",
+        description: "The request_token from Zerodha redirect URL after login"
+      }
+    },
+    required: ["request_token"]
+  },
+  async execute(args, ctx) {
+    try {
+      const apiKey = await ctx.secretsResolver?.get("brokers/zerodha/apiKey");
+      const apiSecret = await ctx.secretsResolver?.get("brokers/zerodha/apiSecret");
+      if (!apiKey || !apiSecret) {
+        return err(
+          "Zerodha credentials not configured. Store apiKey and apiSecret in ~/.ethos/secrets/brokers/zerodha/",
+          "not_available"
+        );
+      }
+      const result = await exchangeToken(apiKey, apiSecret, args.request_token);
+      const ethosDir = process.env.ETHOS_DATA_DIR ?? join(process.env.HOME ?? process.env.USERPROFILE ?? "/tmp", ".ethos");
+      const tokenPath = join(ethosDir, "secrets", "brokers", "zerodha", "accessToken");
+      mkdirSync(dirname(tokenPath), { recursive: true });
+      writeFileSync(tokenPath, result.access_token, { mode: 384 });
+      return ok(
+        JSON.stringify({
+          authenticated: true,
+          user_id: result.user_id,
+          message: "Token valid until midnight IST."
+        })
+      );
+    } catch (e) {
+      return err(e instanceof Error ? e.message : String(e));
+    }
+  }
+});
+var zerodhaAccount = defineTool({
+  name: "zerodha_account",
+  description: `Zerodha account summary \u2014 available funds and margin utilisation.
+Returns net available cash, used margin, unrealised M2M, and option premium blocked.
+All values in INR. Live from Kite API.`,
+  toolset: "broker",
+  maxResultChars: 2e3,
+  capabilities: {
+    network: { allowedHosts: ["api.kite.trade"] },
+    secrets: ["brokers/zerodha/apiKey", "brokers/zerodha/accessToken"]
+  },
+  schema: { type: "object", properties: {} },
+  async execute(_args, ctx) {
+    try {
+      const creds = await getCredentials(ctx);
+      if (isToolResult(creds)) return creds;
+      const margins = await fetchMargins(creds);
+      const eq = margins.equity;
+      return ok(
+        JSON.stringify({
+          net_available_inr: eq.net,
+          opening_balance_inr: eq.available.opening_balance,
+          m2m_unrealised_inr: eq.utilised.m2m_unrealised,
+          exposure_used_inr: eq.utilised.exposure,
+          option_premium_blocked_inr: eq.utilised.option_premium,
+          equity_enabled: eq.enabled
+        })
+      );
+    } catch (e) {
+      if (e instanceof KiteTokenExpiredError) {
+        return tokenExpiredResult();
+      }
+      return err(e instanceof Error ? e.message : String(e));
+    }
+  }
+});
+var zerodhaHoldings = defineTool({
+  name: "zerodha_holdings",
+  description: `Equity holdings (long-term CNC positions) with P&L.
+Returns all stocks held in Zerodha DEMAT \u2014 symbol, quantity, average cost, current price,
+unrealised P&L, and day change. Refreshes cache if >1 hour stale. Values in INR.`,
+  toolset: "broker",
+  maxResultChars: 8e3,
+  capabilities: {
+    network: { allowedHosts: ["api.kite.trade"] },
+    secrets: ["brokers/zerodha/apiKey", "brokers/zerodha/accessToken"]
+  },
+  schema: {
+    type: "object",
+    properties: {
+      force_refresh: {
+        type: "boolean",
+        description: "Force live fetch bypassing 1h cache (default false)"
+      }
+    }
+  },
+  async execute(args, ctx) {
+    try {
+      const creds = await getCredentials(ctx);
+      if (isToolResult(creds)) return creds;
+      const store = new ZerodhaStore(defaultDbPath());
+      try {
+        const forceRefresh = args.force_refresh ?? false;
+        const stale = store.isStale("holdings", TTL.HOLDINGS);
+        if (forceRefresh || stale) {
+          const kiteHoldings = await fetchHoldings(creds);
+          const now = Date.now();
+          const rows = kiteHoldings.map((h) => kiteHoldingToRow(h, now));
+          store.replaceHoldings(rows);
+        }
+        const holdings = store.getHoldings();
+        const totalInvested = holdings.reduce((s, h) => s + h.quantity * h.avgPrice, 0);
+        const totalCurrent = holdings.reduce((s, h) => s + h.quantity * (h.ltp ?? h.avgPrice), 0);
+        const totalPnl = totalCurrent - totalInvested;
+        const totalPnlPct = totalInvested > 0 ? totalPnl / totalInvested * 100 : 0;
+        return ok(
+          JSON.stringify({
+            refreshed_at: new Date(store.getLastFetchedAt("holdings") || Date.now()).toISOString(),
+            count: holdings.length,
+            total_invested_inr: Number(totalInvested.toFixed(2)),
+            total_current_inr: Number(totalCurrent.toFixed(2)),
+            total_pnl_inr: Number(totalPnl.toFixed(2)),
+            total_pnl_pct: Number(totalPnlPct.toFixed(2)),
+            holdings: holdings.map((h) => ({
+              symbol: h.symbol,
+              exchange: h.exchange,
+              quantity: h.quantity,
+              avg_price: h.avgPrice,
+              ltp: h.ltp,
+              pnl_inr: h.pnl,
+              pnl_pct: h.pnlPct,
+              day_change_pct: h.dayChange
+            }))
+          })
+        );
+      } finally {
+        store.close();
+      }
+    } catch (e) {
+      if (e instanceof KiteTokenExpiredError) {
+        return tokenExpiredResult();
+      }
+      return err(e instanceof Error ? e.message : String(e));
+    }
+  }
+});
+var zerodhaPositions = defineTool({
+  name: "zerodha_positions",
+  description: `Open intraday and overnight positions with real-time P&L.
+Returns both day (MIS \u2014 intraday) and net (NRML/CNC \u2014 overnight carry) positions.
+If no open positions, returns an empty list. Values in INR. Always live from Kite API.`,
+  toolset: "broker",
+  maxResultChars: 6e3,
+  capabilities: {
+    network: { allowedHosts: ["api.kite.trade"] },
+    secrets: ["brokers/zerodha/apiKey", "brokers/zerodha/accessToken"]
+  },
+  schema: { type: "object", properties: {} },
+  async execute(_args, ctx) {
+    try {
+      const creds = await getCredentials(ctx);
+      if (isToolResult(creds)) return creds;
+      const positions = await fetchPositions(creds);
+      const dayPnl = positions.day.reduce((s, p) => s + p.pnl, 0);
+      return ok(
+        JSON.stringify({
+          day_positions: positions.day.map((p) => ({
+            symbol: p.tradingsymbol,
+            exchange: p.exchange,
+            product: p.product,
+            quantity: p.quantity,
+            avg_price: p.average_price,
+            ltp: p.last_price,
+            pnl_inr: p.pnl,
+            unrealised_inr: p.unrealised
+          })),
+          net_positions: positions.net.map((p) => ({
+            symbol: p.tradingsymbol,
+            exchange: p.exchange,
+            product: p.product,
+            quantity: p.quantity,
+            avg_price: p.average_price,
+            ltp: p.last_price,
+            pnl_inr: p.pnl,
+            unrealised_inr: p.unrealised
+          })),
+          total_day_pnl_inr: Number(dayPnl.toFixed(2))
+        })
+      );
+    } catch (e) {
+      if (e instanceof KiteTokenExpiredError) {
+        return tokenExpiredResult();
+      }
+      return err(e instanceof Error ? e.message : String(e));
+    }
+  }
+});
+var zerodhaOrders = defineTool({
+  name: "zerodha_orders",
+  description: `Today's order book \u2014 all orders placed, modified, or cancelled today.
+Returns order status, fill price, rejection reason. Always live from Kite API.
+Does NOT return historical orders from previous days (Zerodha API limitation).`,
+  toolset: "broker",
+  maxResultChars: 6e3,
+  capabilities: {
+    network: { allowedHosts: ["api.kite.trade"] },
+    secrets: ["brokers/zerodha/apiKey", "brokers/zerodha/accessToken"]
+  },
+  schema: { type: "object", properties: {} },
+  async execute(_args, ctx) {
+    try {
+      const creds = await getCredentials(ctx);
+      if (isToolResult(creds)) return creds;
+      const orders = await fetchOrders(creds);
+      return ok(
+        JSON.stringify({
+          count: orders.length,
+          orders: orders.map((o) => ({
+            order_id: o.order_id,
+            symbol: o.tradingsymbol,
+            side: o.transaction_type,
+            quantity: o.quantity,
+            order_type: o.order_type,
+            price: o.price,
+            status: o.status,
+            filled_price: o.average_price,
+            time: o.order_timestamp
+          }))
+        })
+      );
+    } catch (e) {
+      if (e instanceof KiteTokenExpiredError) {
+        return tokenExpiredResult();
+      }
+      return err(e instanceof Error ? e.message : String(e));
+    }
+  }
+});
+var zerodhaPlaceOrder = defineTool({
+  name: "zerodha_place_order",
+  description: `Propose or place an equity order via Zerodha Kite.
+
+IMPORTANT SAFETY RULES:
+- dry_run defaults to TRUE. With dry_run: true, the order is SIMULATED \u2014 no real trade is placed.
+  The agent will describe what would happen and log it to the audit trail.
+- To place a REAL order: the user must explicitly say "confirm: true" in their message.
+  Do not set confirm: true without explicit user instruction.
+- Only NSE/BSE equity (CNC product) orders are supported. No MIS intraday, no F&O.
+- Market hours only: 09:15\u201315:30 IST Monday\u2013Friday. AMO (After Market Order) requires variety: 'amo'.
+
+Before placing any real order, always call zerodha_holdings to verify the position context.`,
+  toolset: "broker",
+  maxResultChars: 2e3,
+  capabilities: {
+    network: { allowedHosts: ["api.kite.trade"] },
+    secrets: ["brokers/zerodha/apiKey", "brokers/zerodha/accessToken"]
+  },
+  schema: {
+    type: "object",
+    properties: {
+      symbol: {
+        type: "string",
+        description: "NSE/BSE symbol (e.g. RELIANCE, TCS, INFY)"
+      },
+      exchange: {
+        type: "string",
+        enum: ["NSE", "BSE"],
+        description: "Exchange (default NSE)"
+      },
+      side: {
+        type: "string",
+        enum: ["BUY", "SELL"],
+        description: "Transaction type"
+      },
+      quantity: {
+        type: "number",
+        description: "Number of shares (must be positive integer)"
+      },
+      order_type: {
+        type: "string",
+        enum: ["MARKET", "LIMIT"],
+        description: "MARKET executes immediately at best price; LIMIT requires price parameter"
+      },
+      price: {
+        type: "number",
+        description: "Limit price in INR (required for LIMIT orders)"
+      },
+      dry_run: {
+        type: "boolean",
+        description: "Simulate only \u2014 do NOT place a real order (default: true). Set false only when user explicitly confirms."
+      },
+      variety: {
+        type: "string",
+        enum: ["regular", "amo"],
+        description: "Order variety: 'regular' (market hours) or 'amo' (after market, 3:45\u20138:57 AM next day). Default: regular"
+      }
+    },
+    required: ["symbol", "side", "quantity", "order_type"]
+  },
+  async execute(args, ctx) {
+    try {
+      const creds = await getCredentials(ctx);
+      if (isToolResult(creds)) return creds;
+      const exchange = args.exchange ?? "NSE";
+      const dryRun = args.dry_run !== false;
+      const variety = args.variety ?? "regular";
+      const product = "CNC";
+      const orderId = randomUUID();
+      const now = Date.now();
+      if (dryRun) {
+        const priceStr = args.order_type === "LIMIT" && args.price != null ? `LIMIT ${args.price.toFixed(2)}` : "MARKET";
+        const estimatedCost = args.price != null ? args.quantity * args.price : null;
+        const description = `Would place: ${args.side} ${args.quantity} ${args.symbol} @ ${priceStr} on ${exchange} (${product})`;
+        const store2 = new ZerodhaStore(defaultDbPath());
+        try {
+          store2.logOrder({
+            id: orderId,
+            createdAt: now,
+            symbol: args.symbol,
+            exchange,
+            transaction: args.side,
+            quantity: args.quantity,
+            orderType: args.order_type,
+            price: args.price ?? null,
+            product,
+            dryRun: true,
+            kiteOrderId: null,
+            status: "dry_run",
+            rejectionReason: null,
+            agentSession: null
+          });
+        } finally {
+          store2.close();
+        }
+        return ok(
+          JSON.stringify({
+            dry_run: true,
+            description,
+            estimated_cost_inr: estimatedCost,
+            estimated_brokerage_inr: 0,
+            // Zerodha zero brokerage on delivery
+            logged: true,
+            to_place_for_real: "Add dry_run: false to this request after confirming"
+          })
+        );
+      }
+      const result = await placeOrder(creds, {
+        exchange,
+        tradingsymbol: args.symbol,
+        transaction_type: args.side,
+        quantity: args.quantity,
+        order_type: args.order_type,
+        product,
+        price: args.price,
+        variety
+      });
+      const store = new ZerodhaStore(defaultDbPath());
+      try {
+        store.logOrder({
+          id: orderId,
+          createdAt: now,
+          symbol: args.symbol,
+          exchange,
+          transaction: args.side,
+          quantity: args.quantity,
+          orderType: args.order_type,
+          price: args.price ?? null,
+          product,
+          dryRun: false,
+          kiteOrderId: result.order_id,
+          status: "placed",
+          rejectionReason: null,
+          agentSession: null
+        });
+      } finally {
+        store.close();
+      }
+      return ok(
+        JSON.stringify({
+          dry_run: false,
+          order_id: result.order_id,
+          status: "placed",
+          symbol: args.symbol,
+          side: args.side,
+          quantity: args.quantity,
+          order_type: args.order_type,
+          price: args.price ?? null
+        })
+      );
+    } catch (e) {
+      if (e instanceof KiteTokenExpiredError) {
+        return tokenExpiredResult();
+      }
+      return err(e instanceof Error ? e.message : String(e));
+    }
+  }
+});
+var plugin = {
+  activate(api) {
+    for (const tool of createZerodhaTools()) {
+      api.registerTool(tool);
+    }
+  }
+};
+function activate(api) {
+  for (const tool of createZerodhaTools()) {
+    api.registerTool(tool);
+  }
+}
+function createZerodhaTools() {
+  return [
+    zerodhaAuthStatus,
+    zerodhaAuthComplete,
+    zerodhaAccount,
+    zerodhaHoldings,
+    zerodhaPositions,
+    zerodhaOrders,
+    zerodhaPlaceOrder
+  ];
+}
+export {
+  TTL,
+  ZerodhaStore,
+  activate,
+  buildLoginUrl,
+  createZerodhaTools as createTools,
+  createZerodhaTools,
+  exchangeToken,
+  plugin,
+  validateToken
+};
+//# sourceMappingURL=index.js.map