@circuitorg/agent-sdk 1.1.8 → 1.2.0

package/index.d.ts

@@ -29,23 +29,33 @@ type SignAndSendRequest = {
         hexTransaction: string;
     };
 });
+/**
+ * Success data from signAndSend operations
+ */
+type SignAndSendData = {
+    /** Internal transaction ID for tracking */
+    internalTransactionId: number;
+    /** Transaction hash once broadcast */
+    txHash: string;
+    /** Optional transaction URL (explorer link) */
+    transactionUrl?: string;
+};
 /**
  * Standard response from signAndSend operations
  */
 type SignAndSendResponse = {
     /** Whether the operation was successful */
     success: boolean;
-    /** Internal transaction ID for tracking (only present on success) */
-    internalTransactionId?: number;
-    /** Transaction hash once broadcast (only present on success) */
-    txHash?: string;
-    /** Optional transaction URL (explorer link) (only present on success) */
-    transactionUrl?: string;
-    /** Error message (only present on failure) */
+    /** Transaction data (only present on success) */
+    data?: SignAndSendData;
+    /** Error category from API (only present on failure) */
     error?: string;
+    /** Detailed error message from API (only present on failure) */
+    errorMessage?: string;
     /** Detailed error information (only present on failure) */
     errorDetails?: {
-        message: string;
+        message?: string;
+        error?: string;
         status?: number;
         statusText?: string;
     };
@@ -95,9 +105,9 @@ type SignMessageRequest = {
     };
 });
 /**
- * Standard response from signMessage operations
+ * Success data from signMessage operations
  */
-type SignMessageResponse = {
+type SignMessageData = {
     /** Signature component v */
     v: number;
     /** Signature component r */
@@ -109,6 +119,26 @@ type SignMessageResponse = {
     /** Signature type */
     type: "evm";
 };
+/**
+ * Standard response from signMessage operations
+ */
+type SignMessageResponse = {
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Signature data (only present on success) */
+    data?: SignMessageData;
+    /** Error category from API (only present on failure) */
+    error?: string;
+    /** Detailed error message from API (only present on failure) */
+    errorMessage?: string;
+    /** Detailed error information (only present on failure) */
+    errorDetails?: {
+        message?: string;
+        error?: string;
+        status?: number;
+        statusText?: string;
+    };
+};
 
 /**
  * Agent log type definitions for agent communication
@@ -128,6 +158,18 @@ declare const AgentLogSchema: z.ZodObject<{
     shortMessage: z.ZodString;
 }, z.core.$strip>;
 type AgentLog = z.infer<typeof AgentLogSchema>;
+/**
+ * Response from agent.log() method
+ *
+ * The log method accepts strings, objects, or arrays and pretty-prints them to console.
+ * Objects and arrays are serialized to JSON for backend (truncated to 250 chars).
+ */
+interface LogResponse {
+    success: boolean;
+    error?: string;
+    errorMessage?: string;
+    errorDetails?: object;
+}
 
 /**
  * Configuration type definitions for the Agent SDK
@@ -138,11 +180,7 @@ type AgentLog = z.infer<typeof AgentLogSchema>;
 interface SDKConfig {
     /** Session ID for the current agent instance */
     sessionId: number;
-    /** Enable verbose logging for debugging */
-    verbose?: boolean;
-    /** Enable testing mode to return mock responses */
-    testing?: boolean;
-    /** Optional base URL for local development (auto-detected if omitted) */
+    /** Optional base URL (auto-detected if omitted - internal use only) */
     baseUrl?: string;
 }
 
@@ -176,10 +214,79 @@ declare const SwidgeQuoteRequestSchema: z.ZodObject<{
     fromToken: z.ZodOptional<z.ZodString>;
     toToken: z.ZodOptional<z.ZodString>;
     amount: z.ZodString;
-    priceImpact: z.ZodOptional<z.ZodString>;
     slippage: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type SwidgeQuoteRequest = z.infer<typeof SwidgeQuoteRequestSchema>;
+declare const SwidgeQuoteDataSchema: z.ZodObject<{
+    engine: z.ZodLiteral<"relay">;
+    assetSend: z.ZodObject<{
+        network: z.ZodUnion<readonly [z.ZodLiteral<"solana">, z.ZodTemplateLiteral<`ethereum:${number}`>]>;
+        address: z.ZodString;
+        token: z.ZodNullable<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodOptional<z.ZodString>;
+        decimals: z.ZodOptional<z.ZodNumber>;
+        amount: z.ZodOptional<z.ZodString>;
+        minimumAmount: z.ZodOptional<z.ZodString>;
+        amountFormatted: z.ZodOptional<z.ZodString>;
+        amountUsd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    assetReceive: z.ZodObject<{
+        network: z.ZodUnion<readonly [z.ZodLiteral<"solana">, z.ZodTemplateLiteral<`ethereum:${number}`>]>;
+        address: z.ZodString;
+        token: z.ZodNullable<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodOptional<z.ZodString>;
+        decimals: z.ZodOptional<z.ZodNumber>;
+        amount: z.ZodOptional<z.ZodString>;
+        minimumAmount: z.ZodOptional<z.ZodString>;
+        amountFormatted: z.ZodOptional<z.ZodString>;
+        amountUsd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    priceImpact: z.ZodObject<{
+        usd: z.ZodOptional<z.ZodString>;
+        percentage: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    fees: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        amount: z.ZodOptional<z.ZodString>;
+        amountFormatted: z.ZodOptional<z.ZodString>;
+        amountUsd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"transaction">;
+        description: z.ZodString;
+        transactionDetails: z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"evm">;
+            from: z.ZodString;
+            to: z.ZodString;
+            chainId: z.ZodNumber;
+            value: z.ZodNumber;
+            data: z.ZodString;
+            gas: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxFeePerGas: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxPriorityFeePerGas: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"solana">;
+            instructions: z.ZodArray<z.ZodObject<{
+                programId: z.ZodString;
+                keys: z.ZodArray<z.ZodObject<{
+                    pubkey: z.ZodString;
+                    isSigner: z.ZodBoolean;
+                    isWritable: z.ZodBoolean;
+                }, z.core.$strip>>;
+                data: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>]>;
+            }, z.core.$strip>>;
+            addressLookupTableAddresses: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>]>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"signature">;
+        description: z.ZodString;
+        signatureData: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
 /**
  * Execute request schema - takes the complete quote response from quote() method
  */
@@ -229,9 +336,9 @@ declare const SwidgeExecuteRequestSchema: z.ZodObject<{
             chainId: z.ZodNumber;
             value: z.ZodNumber;
             data: z.ZodString;
-            gas: z.ZodOptional<z.ZodNumber>;
-            maxFeePerGas: z.ZodOptional<z.ZodNumber>;
-            maxPriorityFeePerGas: z.ZodOptional<z.ZodNumber>;
+            gas: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxFeePerGas: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxPriorityFeePerGas: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<"solana">;
             instructions: z.ZodArray<z.ZodObject<{
@@ -321,9 +428,9 @@ declare const SwidgeQuoteResponseWrapperSchema: z.ZodObject<{
                 chainId: z.ZodNumber;
                 value: z.ZodNumber;
                 data: z.ZodString;
-                gas: z.ZodOptional<z.ZodNumber>;
-                maxFeePerGas: z.ZodOptional<z.ZodNumber>;
-                maxPriorityFeePerGas: z.ZodOptional<z.ZodNumber>;
+                gas: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                maxFeePerGas: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                maxPriorityFeePerGas: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"solana">;
                 instructions: z.ZodArray<z.ZodObject<{
@@ -346,8 +453,10 @@ declare const SwidgeQuoteResponseWrapperSchema: z.ZodObject<{
         }, z.core.$strip>], "type">>;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
     errorDetails: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodNumber>;
         statusText: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
@@ -370,38 +479,19 @@ declare const SwidgeExecuteResponseWrapperSchema: z.ZodObject<{
         lastUpdated: z.ZodNumber;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
     errorDetails: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodNumber>;
         statusText: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+type SwidgeQuoteData = z.infer<typeof SwidgeQuoteDataSchema>;
 type SwidgeQuoteResponse = z.infer<typeof SwidgeQuoteResponseWrapperSchema>;
 type SwidgeExecuteRequest = z.infer<typeof SwidgeExecuteRequestSchema>;
 type SwidgeExecuteResponse = z.infer<typeof SwidgeExecuteResponseWrapperSchema>;
 
-declare const PolymarketPositionSchema: z.ZodObject<{
-    contractAddress: z.ZodString;
-    tokenId: z.ZodNullable<z.ZodString>;
-    decimals: z.ZodNumber;
-    conditionId: z.ZodString;
-    formattedShares: z.ZodString;
-    shares: z.ZodString;
-    valueUsd: z.ZodString;
-    question: z.ZodString;
-    outcome: z.ZodString;
-    priceUsd: z.ZodString;
-    averagePriceUsd: z.ZodString;
-    isRedeemable: z.ZodBoolean;
-    isNegativeRisk: z.ZodBoolean;
-    imageUrl: z.ZodString;
-    initialValue: z.ZodString;
-    pnlUsd: z.ZodString;
-    pnlPercent: z.ZodString;
-    pnlRealizedUsd: z.ZodString;
-    pnlRealizedPercent: z.ZodString;
-    endDate: z.ZodString;
-}, z.core.$strip>;
 declare const PolymarketMarketOrderRequestSchema: z.ZodObject<{
     tokenId: z.ZodString;
     size: z.ZodNumber;
@@ -413,40 +503,6 @@ declare const PolymarketMarketOrderRequestSchema: z.ZodObject<{
 declare const PolymarketRedeemPositionsRequestSchema: z.ZodObject<{
     tokenIds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
-declare const PolymarketPositionsResponseSchema: z.ZodObject<{
-    success: z.ZodBoolean;
-    data: z.ZodOptional<z.ZodObject<{
-        totalValue: z.ZodNumber;
-        positions: z.ZodArray<z.ZodObject<{
-            contractAddress: z.ZodString;
-            tokenId: z.ZodNullable<z.ZodString>;
-            decimals: z.ZodNumber;
-            conditionId: z.ZodString;
-            formattedShares: z.ZodString;
-            shares: z.ZodString;
-            valueUsd: z.ZodString;
-            question: z.ZodString;
-            outcome: z.ZodString;
-            priceUsd: z.ZodString;
-            averagePriceUsd: z.ZodString;
-            isRedeemable: z.ZodBoolean;
-            isNegativeRisk: z.ZodBoolean;
-            imageUrl: z.ZodString;
-            initialValue: z.ZodString;
-            pnlUsd: z.ZodString;
-            pnlPercent: z.ZodString;
-            pnlRealizedUsd: z.ZodString;
-            pnlRealizedPercent: z.ZodString;
-            endDate: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    error: z.ZodOptional<z.ZodString>;
-    errorDetails: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
-        status: z.ZodOptional<z.ZodNumber>;
-        statusText: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
 declare const PolymarketMarketOrderResponseSchema: z.ZodObject<{
     success: z.ZodBoolean;
     data: z.ZodOptional<z.ZodObject<{
@@ -461,8 +517,10 @@ declare const PolymarketMarketOrderResponseSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
     errorDetails: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodNumber>;
         statusText: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
@@ -496,16 +554,16 @@ declare const PolymarketRedeemPositionsResponseSchema: z.ZodObject<{
         transactionHash: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>>;
     error: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
     errorDetails: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodNumber>;
         statusText: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-type PolymarketPosition = z.infer<typeof PolymarketPositionSchema>;
 type PolymarketMarketOrderRequest = z.infer<typeof PolymarketMarketOrderRequestSchema>;
 type PolymarketRedeemPositionsRequest = z.infer<typeof PolymarketRedeemPositionsRequestSchema>;
-type PolymarketPositionsResponse = z.infer<typeof PolymarketPositionsResponseSchema>;
 type PolymarketMarketOrderResponse = z.infer<typeof PolymarketMarketOrderResponseSchema>;
 type PolymarketRedeemPositionsResponse = z.infer<typeof PolymarketRedeemPositionsResponseSchema>;
 
@@ -516,29 +574,6 @@ type PolymarketRedeemPositionsResponse = z.infer<typeof PolymarketRedeemPosition
  * All keys are automatically namespaced by agentId and sessionId.
  */
 
-/**
- * Request to set a key-value pair in memory
- */
-declare const MemorySetRequestSchema: z.ZodObject<{
-    key: z.ZodString;
-    value: z.ZodString;
-}, z.core.$strip>;
-/**
- * Request to get a value by key from memory
- */
-declare const MemoryGetRequestSchema: z.ZodObject<{
-    key: z.ZodString;
-}, z.core.$strip>;
-/**
- * Request to delete a key from memory
- */
-declare const MemoryDeleteRequestSchema: z.ZodObject<{
-    key: z.ZodString;
-}, z.core.$strip>;
-/**
- * Request to list all keys in memory (no parameters needed)
- */
-declare const MemoryListRequestSchema: z.ZodObject<{}, z.core.$strip>;
 /**
  * Memory set response wrapper
  */
@@ -548,8 +583,10 @@ declare const MemorySetResponseSchema: z.ZodObject<{
         key: z.ZodString;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
     errorDetails: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodNumber>;
         statusText: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
@@ -564,8 +601,10 @@ declare const MemoryGetResponseSchema: z.ZodObject<{
         value: z.ZodString;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
     errorDetails: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodNumber>;
         statusText: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
@@ -579,8 +618,10 @@ declare const MemoryDeleteResponseSchema: z.ZodObject<{
         key: z.ZodString;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
     errorDetails: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodNumber>;
         statusText: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
@@ -595,16 +636,14 @@ declare const MemoryListResponseSchema: z.ZodObject<{
         count: z.ZodNumber;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
     errorDetails: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodNumber>;
         statusText: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-type MemorySetRequest = z.infer<typeof MemorySetRequestSchema>;
-type MemoryGetRequest = z.infer<typeof MemoryGetRequestSchema>;
-type MemoryDeleteRequest = z.infer<typeof MemoryDeleteRequestSchema>;
-type MemoryListRequest = z.infer<typeof MemoryListRequestSchema>;
 type MemorySetResponse = z.infer<typeof MemorySetResponseSchema>;
 type MemoryGetResponse = z.infer<typeof MemoryGetResponseSchema>;
 type MemoryDeleteResponse = z.infer<typeof MemoryDeleteResponseSchema>;
@@ -651,32 +690,18 @@ declare class AgentSdk {
      *
      * @param config - SDK configuration
      * @param config.sessionId - Numeric session identifier that scopes auth and actions
-     * @param config.verbose - When true, prints detailed request/response logs
-     * @param config.testing - When true, short-circuits network calls with mock values
-     * @param config.baseUrl - Override API base URL (detected automatically otherwise)
      * @example
      * ```ts
-     * const sdk = new AgentSdk({ sessionId: 42, verbose: true });
+     * const sdk = new AgentSdk({ sessionId: 42 });
      * ```
      */
     constructor(config: SDKConfig);
-    private logging;
     /**
-     * Add a log to the agent timeline.
-     *
-     * Messages show up in session traces and UIs and are useful for observability,
-     * human-in-the-loop reviews, and debugging.
-     *
-     * @param log - Timeline message
-     * @param log.type - One of: `"observe" | "validate" | "reflect" | "error" | "warning"`
-     * @param log.shortMessage - Short, human-readable message (<= 250 chars)
-     * @returns Resolves when the log is accepted by the backend
-     * @example
-     * ```ts
-     * await sdk.sendLog({ type: "observe", shortMessage: "Starting swap" });
-     * ```
+     * Internal method to send logs to the backend.
+     * Used by AgentContext.log() method.
+     * @internal
      */
-    sendLog(log: AgentLog): Promise<void>;
+    _sendLog(logs: AgentLog[]): Promise<void>;
     /**
      * Sign and broadcast a transaction on the specified network.
      *
@@ -684,30 +709,42 @@ declare class AgentSdk {
      * the minimal request shape for the selected network.
      *
      * @param request - Network-specific transaction input
-     * @param request.network - `"solana"` or `"ethereum:${number}"`
-     * @param request.message - Optional human-readable context message (short), stored with the transaction
+     * @param request.network - `"solana"` or `"ethereum:${number}"` (e.g., "ethereum:1", "ethereum:42161")
+     * @param request.message - Optional context message for observability (max 250 chars)
      * @param request.request - Transaction payload
-     * - For Ethereum: `{ toAddress, data, value }`
-     *   - `toAddress`: recipient contract or EOA as `0x${string}`
-     *   - `data`: calldata as `0x${string}` (use `"0x"` for simple transfers)
-     *   - `value`: stringified wei amount
+     * - For Ethereum: `{ toAddress, data, value, gas?, maxFeePerGas?, maxPriorityFeePerGas?, nonce?, enforceTransactionSuccess? }`
+     *   - `toAddress`: Recipient address as hex string (`0x${string}`)
+     *   - `data`: Calldata as hex string (`0x${string}`, use `"0x"` for simple transfers)
+     *   - `value`: Wei amount as string
+     *   - `gas`: Gas limit (optional)
+     *   - `maxFeePerGas`: Max fee per gas in wei as string (optional)
+     *   - `maxPriorityFeePerGas`: Max priority fee per gas in wei as string (optional)
+     *   - `nonce`: Transaction nonce (optional)
+     *   - `enforceTransactionSuccess`: Enforce transaction success (optional)
      * - For Solana: `{ hexTransaction }`
-     *   - `hexTransaction`: serialized `VersionedTransaction` as hex string
-     * @returns Promise resolving to `{ internalTransactionId, txHash, transactionUrl? }`
-     * @throws Error if the network is unsupported or the backend rejects the request
+     *   - `hexTransaction`: Serialized `VersionedTransaction` as hex string
+     * @returns Promise resolving to SignAndSendResponse with success status and transaction hash or error details
      * @example
      * ```ts
      * // Ethereum (Arbitrum) native transfer
-     * await sdk.signAndSend({
+     * const result = await sdk.signAndSend({
      *   network: "ethereum:42161",
      *   request: {
      *     toAddress: "0xabc..." as `0x${string}`,
      *     data: "0x" as `0x${string}`,
-     *     value: "1000000000000000" // 0.001 ETH
+     *     value: "1000000000000000", // 0.001 ETH
+     *     gas: 21000,
+     *     maxFeePerGas: "20000000000"
      *   },
-     *   message: "Self-transfer demo"
+     *   message: "Transfer"
      * });
      *
+     * if (result.success) {
+     *   console.log(`Transaction sent: ${result.txHash}`);
+     * } else {
+     *   console.error(`Error: ${result.error}`);
+     * }
+     *
      * // Solana
      * await sdk.signAndSend({
      *   network: "solana",
@@ -718,17 +755,24 @@ declare class AgentSdk {
      */
     signAndSend(request: SignAndSendRequest): Promise<SignAndSendResponse>;
     /**
-     * Sign a message using the agent's key.
+     * Sign a message on an EVM network.
      *
-     * This is useful for signing arbitrary messages, such as EIP-712 typed data.
+     * Supports both EIP-712 (typed structured data) and EIP-191 (simple message) signing.
      *
-     * @param request - Message signing request with network-specific parameters
+     * @param request - EVM message signing input
      * @param request.network - `"ethereum:${number}"` for EVM networks
      * @param request.request - Message signing parameters
-     *   - For EIP-712: `{ messageType: "eip712", data: { domain, types, primaryType, message }, chainId }`
-     *   - For EIP-191: `{ messageType: "eip191", data: { message }, chainId }`
-     * @returns Promise resolving to signature components `{ v, r, s, formattedSignature, type }`
-     * @throws Error if the network is unsupported or the backend rejects the request
+     *   - `messageType`: "eip712" or "eip191"
+     *   - `chainId`: Ethereum chain ID
+     *   - `data`: Message data structure
+     *     - For EIP-712: `{ domain, types, primaryType, message }` with full typed data structure
+     *     - For EIP-191: `{ message }` with the plain text message to sign
+     * @returns Promise resolving to SignMessageResponse with signature components
+     *   - `v`: Signature v component
+     *   - `r`: Signature r component (hex string)
+     *   - `s`: Signature s component (hex string)
+     *   - `formattedSignature`: Complete signature string (hex)
+     *   - `type`: Always "evm"
      * @example
      * ```ts
      * // EIP-191 simple message signing
@@ -740,14 +784,33 @@ declare class AgentSdk {
      *     chainId: 1
      *   }
      * });
+     * console.log(`Signature: ${signature.formattedSignature}`);
      *
-     * // EIP-712 typed data signing
-     * const signature = await sdk.signMessage({
-     *   network: "ethereum:1",
+     * // EIP-712 typed data signing (for Polymarket orders, etc.)
+     * const typedSignature = await sdk.signMessage({
+     *   network: "ethereum:137",
      *   request: {
      *     messageType: "eip712",
-     *     data: { domain: {...}, types: {...}, primaryType: "Message", message: {...} },
-     *     chainId: 1
+     *     chainId: 137,
+     *     data: {
+     *       domain: {
+     *         name: "MyApp",
+     *         version: "1",
+     *         chainId: 137,
+     *         verifyingContract: "0x..."
+     *       },
+     *       types: {
+     *         Order: [
+     *           { name: "maker", type: "address" },
+     *           { name: "amount", type: "uint256" }
+     *         ]
+     *       },
+     *       primaryType: "Order",
+     *       message: {
+     *         maker: "0x...",
+     *         amount: "1000000"
+     *       }
+     *     }
      *   }
      * });
      * ```
@@ -774,15 +837,24 @@ declare class AgentSdk {
          * - **Different networks = bridge**: Same network = swap
          * - **Native tokens**: Omit `fromToken`/`toToken` for ETH, SOL, etc.
          *
-         * @param request Quote parameters
-         * @param request.from Source wallet `{ network, address }`
-         * @param request.to Destination wallet `{ network, address }`
-         * @param request.amount Amount in token's smallest unit (wei for ETH, lamports for SOL)
+         * @param request Quote parameters with wallet info, amount, and optional tokens/slippage
+         * @param request.from Source wallet `{ network: "ethereum:1" | "ethereum:42161" | etc., address: "0x..." }`
+         * @param request.to Destination wallet `{ network: "ethereum:42161" | "solana" | etc., address: "0x..." | "base58" }`
+         * @param request.amount Amount in smallest unit (e.g., "1000000000000000000" for 1 ETH, wei for EVM, lamports for Solana)
          * @param request.fromToken Source token contract address (optional, omit for native tokens like ETH/SOL)
          * @param request.toToken Destination token contract address (optional, omit for native tokens like ETH/SOL)
-         * @param request.slippage Slippage tolerance % as string (e.g., "2.0" = 2%, default: "0.5")
-         * @param request.priceImpact Max price impact % as string (e.g., "1.0" = 1%, default: "0.5")
-         * @returns Quote with fees, price impact, and transaction steps
+         * @param request.slippage Slippage tolerance % as string (default: "0.5", e.g., "2.0" = 2% slippage)
+         * @param request.priceImpact Max price impact % as string (default: "0.5", e.g., "1.0" = 1% price impact)
+         * @returns SwidgeQuoteResponse with pricing, fees, and transaction steps
+         *   - `success` (boolean): Whether the quote was retrieved successfully
+         *   - `data` (SwidgeQuoteData | undefined): Quote data containing:
+         *     - `assetSend`: Source asset details with amount and decimals
+         *     - `assetReceive`: Destination asset details with expected amount
+         *     - `fees`: Array of fee breakdown (network fees, bridge fees, etc.)
+         *     - `steps`: Transaction steps required to complete the swap
+         *     - `priceImpact`: Calculated price impact percentage
+         *   - `error` (string | undefined): Error message if quote failed
+         *   - `errorDetails` (object | undefined): Detailed error information
          *
          * @example
          * ```ts
@@ -807,18 +879,12 @@ declare class AgentSdk {
          *   // slippage defaults to "0.5", priceImpact defaults to "0.5"
          * });
          *
-         * if (quote.success) {
+         * if (quote.success && quote.data) {
          *   console.log(`💰 You'll receive: ${quote.data.assetReceive.amountFormatted}`);
          *   console.log(`💸 Total fees: ${quote.data.fees.map(f => f.name).join(", ")}`);
+         *   console.log(`📊 Price impact: ${quote.data.priceImpact}%`);
          * } else if (quote.error) {
-         *   // Check for specific error types
-         *   if (quote.error === QUOTE_RESULT.WALLET_NOT_FOUND) {
-         *     console.log("👛 Wallet not found");
-         *   } else if (quote.error === QUOTE_RESULT.WALLET_MISMATCH) {
-         *     console.log("🔐 Wallet address doesn't match session");
-         *   } else {
-         *     console.log("❓ Quote not available for this swap");
-         *   }
+         *   console.error(`❌ Quote failed: ${quote.error}`);
          * }
          * ```
          */
@@ -838,8 +904,16 @@ declare class AgentSdk {
          *
          * 💡 **Pro tip**: The backend handles all the complexity - you just pass the quote!
          *
-         * @param quote Complete quote object from `sdk.swidge.quote()`
-         * @returns Execution result with status and transaction details
+         * @param quote Complete quote object from `sdk.swidge.quote()` (the entire `data` field from the quote response)
+         * @returns SwidgeExecuteResponse with transaction status and details
+         *   - `success` (boolean): Whether the execution was successful
+         *   - `data` (SwidgeExecuteData | undefined): Execution result containing:
+         *     - `status`: "success" | "failure" | "refund" | "delayed" - Final transaction status
+         *     - `in`: Source transaction details with txs array (transaction hashes)
+         *     - `out`: Destination transaction details with txs array (transaction hashes)
+         *     - Additional metadata about the swap/bridge operation
+         *   - `error` (string | undefined): Error message if execution failed
+         *   - `errorDetails` (object | undefined): Detailed error information
          *
          * @example
          * ```ts
@@ -1010,213 +1084,210 @@ declare class AgentSdk {
         list: () => Promise<MemoryListResponse>;
     };
     /**
-     * 📈 Polymarket: Trade prediction markets seamlessly
+     * 🔌 Platform Integrations
      *
-     * Access Polymarket positions, execute market orders, and redeem positions using your
-     * session wallet. All operations are policy-checked and signed automatically.
+     * Access external platform integrations like Polymarket through the Circuit Agent SDK.
      */
-    readonly polymarket: {
+    readonly platforms: {
         /**
-         * Get current positions on Polymarket
+         * 📈 Polymarket: Trade prediction markets seamlessly
          *
-         * Fetches all open positions for the session wallet, including value, PNL, and market details.
+         * Execute market orders and redeem positions using your session wallet.
+         * All operations are policy-checked and signed automatically.
          *
-         * @returns Wrapped response with positions array and total value
-         * @example
-         * // Usage
-         * const result = await sdk.polymarket.positions();
-         *
-         * if (result.success && result.data) {
-         *   console.log(`Total portfolio value: $${result.data.totalValue}`);
-         *   result.data.positions.forEach(pos => {
-         *     console.log(`${pos.question} - ${pos.outcome}: $${pos.valueUsd} (PNL: ${pos.pnlUsd})`);
-         *   });
-         * } else {
-         *   console.log(`Error: ${result.error}`);
-         * }
-         *
-         * // Input: None (GET request)
-         *
-         * // Output showcase (success case):
-         * {
-         *   success: true,
-         *   data: {
-         *     totalValue: 150.75,
-         *     positions: [
-         *       {
-         *         contractAddress: "0x...",
-         *         tokenId: "123456",
-         *         decimals: 6,
-         *         conditionId: "0x...",
-         *         formattedShares: "10.0",
-         *         shares: "10000000",
-         *         valueUsd: "10.5",
-         *         question: "Will event X happen?",
-         *         outcome: "Yes",
-         *         priceUsd: "1.05",
-         *         averagePriceUsd: "0.95",
-         *         isRedeemable: false,
-         *         imageUrl: "https://...",
-         *         initialValue: "9.5",
-         *         pnlUsd: "1.0",
-         *         pnlPercent: "10.53",
-         *         pnlRealizedUsd: "0",
-         *         pnlRealizedPercent: "0",
-         *         endDate: "2024-12-31"
-         *       },
-         *       // ... more positions
-         *     ]
-         *   }
-         * }
-         *
-         * // Error case:
-         * {
-         *   success: false,
-         *   error: "Could not get positions",
-         *   errorDetails: { message: "Wallet not found", status: 400 }
-         * }
-         */
-        positions: () => Promise<PolymarketPositionsResponse>;
-        /**
-         * Execute a market order on Polymarket
-         *
-         * Places a buy or sell market order for the specified token and size. Handles approvals,
-         * signing, and submission automatically.
-         *
-         * ⚠️ **Important**: The `size` parameter meaning differs by order side:
-         * - **BUY**: `size` is the USD amount to spend (e.g., 10 = $10 worth of shares)
-         * - **SELL**: `size` is the number of shares/tokens to sell (e.g., 10 = 10 shares)
-         *
-         * @param request Order parameters
-         * @param request.tokenId Market token ID for the position
-         * @param request.size For BUY: USD amount to spend. For SELL: Number of shares to sell
-         * @param request.side "BUY" or "SELL"
-         * @returns Wrapped response with order details and submission result
-         * @example
-         * // BUY order - size is USD amount
-         * const buyResult = await sdk.polymarket.marketOrder({
-         *   tokenId: "123456",
-         *   size: 10,        // Spend $10 to buy shares
-         *   side: "BUY"
-         * });
-         *
-         * // SELL order - size is number of shares
-         * const sellResult = await sdk.polymarket.marketOrder({
-         *   tokenId: "123456",
-         *   size: 5,         // Sell 5 shares
-         *   side: "SELL"
-         * });
-         *
-         * if (buyResult.success && buyResult.data) {
-         *   console.log(`Order ID: ${buyResult.data.submitOrder.orderId}`);
-         *   console.log(`Success: ${buyResult.data.submitOrder.success}`);
-         * } else {
-         *   console.log(`Error: ${buyResult.error}`);
-         * }
-         *
-         * // Input showcase:
-         * {
-         *   tokenId: "123456",  // Market token ID
-         *   size: 10,           // BUY: USD amount ($10) | SELL: Number of shares (10 shares)
-         *   side: "BUY"         // or "SELL"
-         * }
-         *
-         * // Output showcase (success case):
-         * {
-         *   success: true,
-         *   data: {
-         *     order: {
-         *       eip712Message: {
-         *         // Typed data for signing (domain, types, message)
-         *       },
-         *       order: {
-         *         salt: "123456789",
-         *         maker: "0x...",
-         *         signer: "0x...",
-         *         taker: "0x...",
-         *         tokenId: "123456",
-         *         makerAmount: "105000000", // USD amount in USDC decimals
-         *         takerAmount: "10000000",  // Shares in decimals
-         *         expiration: "0",
-         *         nonce: "0",
-         *         feeRateBps: "0",
-         *         side: 0,                 // 0 = BUY, 1 = SELL
-         *         signatureType: 0         // 0 = EIP712
-         *       }
-         *     },
-         *     submitOrder: {
-         *       orderId: "abc123",
-         *       success: true,
-         *       errorMessage: ""
-         *     }
-         *   }
-         * }
-         *
-         * // Error case:
-         * {
-         *   success: false,
-         *   error: "Could not get order",
-         *   errorDetails: { message: "Invalid request", status: 400 }
-         * }
-         */
-        marketOrder: (request: PolymarketMarketOrderRequest) => Promise<PolymarketMarketOrderResponse>;
-        /**
-         * Redeem settled positions on Polymarket
-         *
-         * Redeems one or all redeemable positions, claiming winnings. Handles multiple transactions if needed.
-         *
-         * @param request Redemption parameters (omit to redeem all, or pass tokenIds for specific positions)
-         * @returns Wrapped response with per-position redemption results
-         * @example
-         * // Redeem all positions (no arguments - default behavior)
-         * const allResult = await sdk.polymarket.redeemPositions();
-         *
-         * // Redeem specific positions
-         * const specificResult = await sdk.polymarket.redeemPositions({ tokenIds: ["123456", "789012"] });
-         *
-         * if (result.success && result.data) {
-         *   result.data.forEach(tx => {
-         *     if (tx.success && tx.position) {
-         *       console.log(`Redeemed ${tx.position.question}: Tx ${tx.transactionHash}`);
-         *     } else if (tx.success) {
-         *       console.log(`Unwrapped collateral: Tx ${tx.transactionHash}`);
-         *     }
-         *   });
-         * }
-         *
-         * // Input showcase:
-         * // No arguments - redeem all positions (default)
-         * // or
-         * { tokenIds: ["123456", "789012"] } // Redeem specific positions
-         *
-         * // Output showcase (success case):
-         * {
-         *   success: true,
-         *   data: [
-         *     {
-         *       success: true,
-         *       position: {
-         *         // Full position details as in positions response
-         *       },
-         *       transactionHash: "0xabc123..."
-         *     },
-         *     {
-         *       success: true,
-         *       position: null, // null for unwrap collateral transactions
-         *       transactionHash: "0xdef456..."
-         *     },
-         *     // ... more redemptions
-         *   ]
-         * }
-         *
-         * // Error case:
-         * {
-         *   success: false,
-         *   error: "Could not get positions",
-         *   errorDetails: { message: "No redeemable positions", status: 404 }
-         * }
+         * Note: Position data is available via agent.currentPositions in the request.
          */
-        redeemPositions: (request?: PolymarketRedeemPositionsRequest) => Promise<PolymarketRedeemPositionsResponse>;
+        polymarket: {
+            /**
+             * Execute a market order on Polymarket
+             *
+             * Places a buy or sell market order for the specified token and size. Handles approvals,
+             * signing, and submission automatically.
+             *
+             * ⚠️ **Important**: The `size` parameter meaning differs by order side:
+             * - **BUY**: `size` is the USD amount to spend (e.g., 10 = $10 worth of shares)
+             * - **SELL**: `size` is the number of shares/tokens to sell (e.g., 10 = 10 shares)
+             *
+             * **Input**: `PolymarketMarketOrderRequest`
+             *   - `tokenId` (string): Market token ID for the position
+             *   - `size` (number): For BUY: USD amount to spend. For SELL: Number of shares to sell
+             *   - `side` ("BUY" | "SELL"): Order side
+             *
+             * **Output**: `PolymarketMarketOrderResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (PolymarketMarketOrderData | undefined): Market order data (only present on success)
+             *     - `success` (boolean): Whether the order was successfully submitted
+             *     - `orderInfo` (PolymarketOrderInfo): Order information with transaction details
+             *       - `orderId` (string): Unique order identifier
+             *       - `side` (string): Order side ("BUY" or "SELL")
+             *       - `size` (string): Order size
+             *       - `priceUsd` (string): Price per share in USD
+             *       - `totalPriceUsd` (string): Total order value in USD
+             *       - `txHashes` (string[]): List of transaction hashes
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *   - `errorDetails` (object | undefined): Detailed error info
+             *
+             * **Key Functionality**:
+             *   - Automatic approval handling for token spending
+             *   - EIP-712 signature generation for order placement
+             *   - Real-time order submission and confirmation
+             *   - Support for both buy and sell orders
+             *
+             * @param request Order parameters (tokenId, size, side)
+             * @returns Promise resolving to PolymarketMarketOrderResponse with order details and submission result
+             * @example
+             * ```ts
+             * // BUY order - size is USD amount
+             * const buyResult = await sdk.polymarket.marketOrder({
+             *   tokenId: "123456",
+             *   size: 10,  // Spend $10 to buy shares
+             *   side: "BUY"
+             * });
+             *
+             * // SELL order - size is number of shares
+             * const sellResult = await sdk.polymarket.marketOrder({
+             *   tokenId: "123456",
+             *   size: 5,  // Sell 5 shares
+             *   side: "SELL"
+             * });
+             *
+             * if (buyResult.success && buyResult.data) {
+             *   console.log(`Order Success: ${buyResult.data.success}`);
+             *   console.log(`Order ID: ${buyResult.data.orderInfo.orderId}`);
+             *   console.log(`Total Price: $${buyResult.data.orderInfo.totalPriceUsd}`);
+             * } else {
+             *   console.error(`Error: ${buyResult.error}`);
+             * }
+             * ```
+             *
+             * **Success Case**:
+             * ```json
+             * {
+             *   "success": true,
+             *   "data": {
+             *     "success": true,
+             *     "orderInfo": {
+             *       "orderId": "abc123",
+             *       "side": "BUY",
+             *       "size": "10.0",
+             *       "priceUsd": "0.52",
+             *       "totalPriceUsd": "5.20",
+             *       "txHashes": ["0xabc..."]
+             *     }
+             *   },
+             *   "error": undefined
+             * }
+             * ```
+             *
+             * **Error Case**:
+             * ```json
+             * {
+             *   "success": false,
+             *   "data": undefined,
+             *   "error": "Could not get order",
+             *   "errorDetails": { "message": "Invalid request", "status": 400 }
+             * }
+             * ```
+             */
+            marketOrder: (request: PolymarketMarketOrderRequest) => Promise<PolymarketMarketOrderResponse>;
+            /**
+             * Redeem settled positions on Polymarket
+             *
+             * Redeems one or all redeemable positions, claiming winnings. Handles multiple transactions if needed.
+             *
+             * **Input**: `PolymarketRedeemPositionsRequest` (optional, defaults to redeem all)
+             *   - `tokenIds` (string[], optional): List of token IDs to redeem specific positions. Empty or omitted redeems all redeemable positions.
+             *
+             * **Output**: `PolymarketRedeemPositionsResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (PolymarketRedeemPositionResult[] | undefined): Redeem positions data (only present on success)
+             *     - Each result contains:
+             *       - `success` (boolean): Whether redemption was successful
+             *       - `position` (PolymarketPosition | null): Position that was redeemed (full position details, null for unwrap collateral)
+             *       - `transactionHash` (string | null): Transaction hash (null if redemption failed)
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *   - `errorDetails` (object | undefined): Detailed error info
+             *
+             * **Key Functionality**:
+             *   - Automatic detection of redeemable positions
+             *   - Batch redemption support for multiple positions
+             *   - Single position redemption by token ID
+             *   - Transaction tracking for each redemption
+             *
+             * @param request Redemption parameters (tokenIds list for specific positions, empty for all)
+             * @returns Promise resolving to PolymarketRedeemPositionsResponse with per-position redemption results
+             * @example
+             * ```ts
+             * // Redeem all positions (no arguments - default behavior)
+             * const allResult = await sdk.polymarket.redeemPositions();
+             *
+             * // Redeem specific positions
+             * const specificResult = await sdk.polymarket.redeemPositions({
+             *   tokenIds: ["123456", "789012"]
+             * });
+             *
+             * if (allResult.success && allResult.data) {
+             *   for (const tx of allResult.data) {
+             *     if (tx.success && tx.position) {
+             *       console.log(`Redeemed ${tx.position.question}: Tx ${tx.transactionHash}`);
+             *     } else if (tx.success) {
+             *       console.log(`Unwrapped collateral: Tx ${tx.transactionHash}`);
+             *     } else if (tx.position) {
+             *       console.log(`Failed to redeem ${tx.position.question}`);
+             *     }
+             *   }
+             * } else {
+             *   console.error(`Error: ${allResult.error}`);
+             * }
+             * ```
+             *
+             * **Success Case (Multiple Redemptions)**:
+             * ```json
+             * {
+             *   "success": true,
+             *   "data": [
+             *     {
+             *       "success": true,
+             *       "position": {
+             *         "contractAddress": "0x...",
+             *         "tokenId": "123456",
+             *         "question": "Will event X happen?",
+             *         "outcome": "Yes"
+             *       },
+             *       "transactionHash": "0xabc123..."
+             *     },
+             *     {
+             *       "success": true,
+             *       "position": {
+             *         "contractAddress": "0x...",
+             *         "tokenId": "789012",
+             *         "question": "Will event Y happen?",
+             *         "outcome": "No"
+             *       },
+             *       "transactionHash": "0xdef456..."
+             *     },
+             *     {
+             *       "success": true,
+             *       "position": null,
+             *       "transactionHash": "0xghi789..."
+             *     }
+             *   ],
+             *   "error": undefined
+             * }
+             * ```
+             *
+             * **Error Case**:
+             * ```json
+             * {
+             *   "success": false,
+             *   "data": undefined,
+             *   "error": "Could not get positions",
+             *   "errorDetails": { "message": "No redeemable positions", "status": 404 }
+             * }
+             * ```
+             */
+            redeemPositions: (request?: PolymarketRedeemPositionsRequest) => Promise<PolymarketRedeemPositionsResponse>;
+        };
     };
     /**
      * Handle EVM transaction signing and broadcasting
@@ -1230,15 +1301,12 @@ declare class AgentSdk {
      * Handle EVM message signing
      */
     private handleEvmSignMessage;
-    /**
-     * Send logs to the agent timeline (migrated from AgentToolset)
-     */
-    private _sendLog;
     /**
      * Internal method to update job status. Used by the Agent wrapper for automatic tracking.
      *
      * This method is not intended for direct use by agent developers - job status tracking
      * is handled automatically by the Agent wrapper.
+     * @internal
      */
     _updateJobStatus(request: UpdateJobStatusRequest): Promise<UpdateJobStatusResponse>;
     /**
@@ -1249,7 +1317,6 @@ declare class AgentSdk {
      * Handle swidge execute requests
      */
     private handleSwidgeExecute;
-    private handlePolymarketPositions;
     private handlePolymarketMarketOrder;
     private handlePolymarketRedeemPositions;
     /**
@@ -1291,18 +1358,11 @@ declare class APIClient {
      * Create an API client.
      * @param config - SDK configuration
      * @param config.sessionId - Numeric session identifier propagated as header
-     * @param config.baseUrl - Override base URL for local development (auto-detected if omitted)
-     * @param config.verbose - Enable detailed logs for debugging
      */
     constructor(config: SDKConfig);
     private getAgentSlug;
     private getAuthHeaders;
     private loadAuthConfig;
-    private logging;
-    /**
-     * Mask sensitive headers and filter out noise headers for logging
-     */
-    private sanitizeHeaders;
     /**
      * Perform a JSON HTTP request.
      *
@@ -1334,161 +1394,670 @@ declare class APIClient {
 }
 
 /**
- * Request object for agent functions containing session and wallet information.
- * Provided to your `execution`, `chat`, and `stop` handlers.
- */
-declare const AgentRequestSchema: z.ZodObject<{
-    sessionId: z.ZodNumber;
-    sessionWalletAddress: z.ZodString;
-    jobId: z.ZodOptional<z.ZodString>;
-    currentPositions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        network: z.ZodString;
-        assetAddress: z.ZodString;
-        tokenId: z.ZodNullable<z.ZodString>;
-        avgUnitCost: z.ZodString;
-        currentQty: z.ZodString;
-    }, z.core.$strip>>>;
-    otherParameters: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
-}, z.core.$strip>;
-/**
- * Standard response format for agent functions (execute and stop commands).
+ * Unified agent interface combining request data and SDK methods.
+ *
+ * This module provides the AgentContext class that serves as the single interface
+ * agent developers interact with. It combines request metadata with all SDK functionality
+ * into one clean object.
  */
-declare const AgentResponseSchema: z.ZodObject<{
-    success: z.ZodBoolean;
-    error: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+
 /**
- * Health check response format.
+ * Current positions allocated to the agent for this session
  */
-declare const HealthResponseSchema: z.ZodObject<{
-    status: z.ZodString;
-}, z.core.$strip>;
-type AgentRequest = z.infer<typeof AgentRequestSchema>;
-type AgentResponse = z.infer<typeof AgentResponseSchema>;
-type HealthResponse = z.infer<typeof HealthResponseSchema>;
+interface CurrentPosition {
+    network: string;
+    assetAddress: string;
+    tokenId: string | null;
+    avgUnitCost: string;
+    currentQty: string;
+}
 /**
- * Contract for agent execution functions. Called to perform the agent's main task.
- * @param request - Contains session info and wallet address to operate with
- * @returns Promise resolving to a success/error response
+ * Unified interface for agent developers combining request data and SDK methods.
+ *
+ * This class provides everything an agent needs in a single object:
+ * - **Request metadata**: `sessionId`, `sessionWalletAddress`, `currentPositions`
+ * - **Core methods**: `log()`, `signAndSend()`, `signMessage()`
+ * - **Memory operations**: `memory.set()`, `memory.get()`, `memory.delete()`, `memory.list()`
+ * - **Platform integrations**: `platforms.polymarket.*` for prediction market trading
+ * - **Cross-chain swaps**: `swidge.quote()`, `swidge.execute()`
+ *
+ * The agent developer's execution and stop functions receive this object:
+ *
  * @example
  * ```typescript
- * // Execution function implementation
- * const executionFunction: ExecutionFunctionContract = async (request) => {
- *   const agentToolset = new AgentToolset({ sessionId: request.sessionId });
+ * async function execution_function(agent: AgentContext): Promise<void> {
+ *   // Logging
+ *   await agent.log(`Starting execution for session ${agent.sessionId}`);
  *
- *   try {
- *     // Send status message
- *     await agentToolset.sendLog([{
- *       type: "observe",
- *       shortMessage: "Starting agent execution..."
- *     }]);
+ *   // Memory operations
+ *   await agent.memory.set("last_run", Date.now().toString());
+ *   const saved = await agent.memory.get("last_run");
  *
- *     // Example: Send a transaction
- *     const { txResult, broadcastResult } = await agentToolset.transactionSignAndBroadcast({
- *       chainId: 1,
- *       toAddress: request.sessionWalletAddress,
- *       data: "0x",
- *       valueWei: "1000000000000000000" // 1 ETH
- *     });
+ *   // Polymarket trading
+ *   const order = await agent.platforms.polymarket.marketOrder({
+ *     tokenId: "123456",
+ *     size: 10,
+ *     side: "BUY"
+ *   });
+ *
+ *   // Cross-chain swaps
+ *   const quote = await agent.swidge.quote({
+ *     from: { network: "ethereum:1", address: agent.sessionWalletAddress },
+ *     to: { network: "ethereum:42161", address: agent.sessionWalletAddress },
+ *     amount: "1000000000000000000"
+ *   });
  *
- *     if (broadcastResult.status === "broadcasted") {
- *       return {
- *         success: true,
- *         message: "Transaction executed successfully"
- *       };
+ *   // Sign and send transactions
+ *   const tx = await agent.signAndSend({
+ *     network: "ethereum:1",
+ *     request: {
+ *       toAddress: "0x...",
+ *       data: "0x",
+ *       value: "1000000000000000000"
  *     }
+ *   });
  *
- *     return {
- *       success: false,
- *       error: "Transaction failed to broadcast",
- *       message: "Execution failed"
- *     };
- *   } catch (error) {
- *     return {
- *       success: false,
- *       error: error instanceof Error ? error.message : "Unknown error",
- *       message: "Execution failed"
- *     };
- *   }
- * };
+ *   // Sign messages (EIP-712 / EIP-191)
+ *   const signature = await agent.signMessage({
+ *     network: "ethereum:1",
+ *     request: {
+ *       messageType: "eip191",
+ *       data: { message: "Hello!" },
+ *       chainId: 1
+ *     }
+ *   });
+ * }
  * ```
+ *
+ * @property sessionId - Unique session identifier
+ * @property sessionWalletAddress - Wallet address for this session
+ * @property currentPositions - Current positions allocated to this agent
+ *
+ * @property log - Unified logging method that sends messages to console and Circuit UI
+ * @property signAndSend - Sign and broadcast a transaction on Ethereum or Solana
+ * @property signMessage - Sign a message using EIP-712 or EIP-191 on EVM networks
+ *
+ * @property memory - Session-scoped key-value storage
+ * @property memory.set - Store a key-value pair in session memory
+ * @property memory.get - Retrieve a value by key from session memory
+ * @property memory.delete - Delete a key from session memory
+ * @property memory.list - List all keys in session memory
+ *
+ * @property platforms - Platform integrations (Polymarket, etc.)
+ * @property platforms.polymarket - Prediction market trading operations
+ * @property platforms.polymarket.marketOrder - Execute a buy or sell market order on Polymarket
+ * @property platforms.polymarket.redeemPositions - Redeem settled positions and claim winnings
+ *
+ * @property swidge - Cross-chain swap and bridge operations
+ * @property swidge.quote - Get a quote for swapping tokens between networks
+ * @property swidge.execute - Execute a swap using a quote
  */
-type ExecutionFunctionContract = (request: AgentRequest) => Promise<AgentResponse>;
+declare class AgentContext {
+    /** Unique session identifier */
+    readonly sessionId: number;
+    /** Wallet address for this session */
+    readonly sessionWalletAddress: string;
+    /** Current positions allocated to this agent (required) */
+    readonly currentPositions: CurrentPosition[];
+    /** Internal SDK instance */
+    private _sdk;
+    /**
+     * Create a new AgentContext instance.
+     *
+     * This is typically created automatically by the Agent wrapper, but can be
+     * instantiated manually for testing in Jupyter notebooks or scripts.
+     *
+     * @param config - Agent context configuration
+     * @param config.sessionId - Unique session identifier
+     * @param config.sessionWalletAddress - Wallet address for this session
+     * @param config.currentPositions - Current positions allocated to this agent
+     * @param config.baseUrl - Override API base URL (detected automatically otherwise)
+     *
+     * @example
+     * ```typescript
+     * // Manual instantiation for testing
+     * const agent = new AgentContext({
+     *   sessionId: 123,
+     *   sessionWalletAddress: "0x742d35cc6634C0532925a3b8D65e95f32B6b5582",
+     *   currentPositions: []
+     * });
+     * await agent.log("Testing agent functionality");
+     * ```
+     */
+    constructor(config: {
+        sessionId: number;
+        sessionWalletAddress: string;
+        currentPositions: CurrentPosition[];
+        baseUrl?: string;
+    });
+    /**
+     * Unified logging method that handles console output and backend messaging.
+     *
+     * This method always logs to the console, and conditionally sends logs to the
+     * backend based on the flags provided. Accepts strings, objects, or arrays -
+     * structured data is automatically pretty-printed to console and serialized for backend.
+     *
+     * **Handles non-serializable data gracefully:**
+     * - BigInt → converted to string
+     * - Functions → shown as `[Function: name]`
+     * - Custom objects → uses toString() if available
+     *
+     * **Behavior:**
+     * - `agent.log("message")` → console.info() + backend POST with type="observe"
+     * - `agent.log("message", { error: true })` → console.error() + backend POST with type="error"
+     * - `agent.log("message", { debug: true })` → console.info() + NO backend call
+     * - `agent.log({ key: "value" })` → Pretty-printed to console + serialized to backend (truncated to 250 chars)
+     * - `agent.log([1, 2, 3])` → Pretty-printed to console + serialized to backend (truncated to 250 chars)
+     *
+     * **What happens:**
+     * - Default (no flags): Shows in your terminal AND in the Circuit UI for your user
+     * - error: true: Shows as error in terminal AND Circuit UI
+     * - debug: true: Shows ONLY in your terminal (users don't see it)
+     *
+     * @param message - The message to log (string, object, or array) - backend receives max 250 chars
+     * @param options - Logging options
+     * @param options.error - If true, log as error and send to backend as error type (default: false)
+     * @param options.debug - If true, only log to console, skip backend call (default: false)
+     * @returns Promise resolving to LogResponse with success status
+     *
+     * @example
+     * ```typescript
+     * // User sees this in Circuit UI
+     * await agent.log("Opening position on Polymarket");
+     *
+     * // Log an object (pretty-printed)
+     * const response = await agent.memory.get("key");
+     * await agent.log(response);  // Pretty JSON in console, truncated for backend
+     *
+     * // Log a dict/object (pretty-printed)
+     * await agent.log({ wallet: agent.sessionWalletAddress, status: "active" });
+     *
+     * // Log an array (pretty-printed)
+     * await agent.log([{ position: 1 }, { position: 2 }]);
+     *
+     * // Log complex objects with BigInt, functions, etc. - handled automatically
+     * await agent.log({
+     *   amount: 1000000000000000000n, // BigInt
+     *   callback: () => {}, // Function
+     *   positions: agent.currentPositions
+     * });
+     *
+     * // User sees error in Circuit UI
+     * const result = await agent.memory.get("key");
+     * if (!result.success) {
+     *   await agent.log("Failed to load saved settings", { error: true });
+     * }
+     *
+     * // Only you see this in your terminal
+     * await agent.log("Internal debug info", { debug: true });
+     * ```
+     */
+    log(message: string | object | any[], options?: {
+        error?: boolean;
+        debug?: boolean;
+    }): Promise<LogResponse>;
+    /**
+     * Sign and broadcast a transaction on the specified network.
+     *
+     * Delegates to the underlying SDK's signAndSend method.
+     *
+     * **Input**: `SignAndSendRequest`
+     *   - `network` (string): "solana" or "ethereum:chainId" (e.g., "ethereum:1", "ethereum:42161")
+     *   - `message` (string | undefined): Optional context message (max 250 chars)
+     *   - `request` (object): Transaction payload
+     *     - For Ethereum:
+     *       - `toAddress` (string): Recipient address as hex string
+     *       - `data` (string): Calldata as hex string (use "0x" for transfers)
+     *       - `value` (string): Wei amount as string
+     *       - `gas` (number, optional): Gas limit
+     *       - `maxFeePerGas` (string, optional): Max fee per gas in wei
+     *       - `maxPriorityFeePerGas` (string, optional): Max priority fee per gas in wei
+     *       - `nonce` (number, optional): Transaction nonce
+     *       - `enforceTransactionSuccess` (boolean, optional): Enforce transaction success
+     *     - For Solana:
+     *       - `hexTransaction` (string): Serialized VersionedTransaction as hex string
+     *
+     * **Output**: `SignAndSendResponse`
+     *   - `success` (boolean): Whether the operation succeeded
+     *   - `txHash` (string | undefined): Transaction hash on success
+     *   - `transactionUrl` (string | undefined): Explorer link on success
+     *   - `internalTransactionId` (number | undefined): Internal tracking ID
+     *   - `error` (string | undefined): Error message on failure
+     *   - `errorDetails` (object | undefined): Detailed error info
+     *
+     * @param request - Transaction request with network and transaction details
+     * @returns Promise resolving to SignAndSendResponse with transaction hash or error details
+     *
+     * @example
+     * ```typescript
+     * const response = await agent.signAndSend({
+     *   network: "ethereum:42161",
+     *   request: {
+     *     toAddress: "0x742d35cc6634C0532925a3b8D65e95f32B6b5582",
+     *     data: "0x",
+     *     value: "1000000000000000000",  // 1 ETH
+     *     gas: 21000,
+     *     maxFeePerGas: "20000000000"
+     *   },
+     *   message: "Sending 1 ETH"
+     * });
+     *
+     * if (response.success) {
+     *   await agent.log(`Transaction sent: ${response.txHash}`);
+     * } else {
+     *   await agent.log(response.error || 'Transaction failed', { error: true });
+     * }
+     * ```
+     */
+    signAndSend(request: SignAndSendRequest): Promise<SignAndSendResponse>;
+    /**
+     * Sign a message on an EVM network.
+     *
+     * Delegates to the underlying SDK's signMessage method.
+     * Supports both EIP-712 (typed structured data) and EIP-191 (simple message) signing.
+     *
+     * **Input**: `SignMessageRequest`
+     *   - `network` (string): "ethereum:chainId" for EVM networks
+     *   - `request` (object): Message signing parameters
+     *     - `messageType` (string): "eip712" or "eip191"
+     *     - `chainId` (number): Ethereum chain ID
+     *     - `data` (object): Message data structure
+     *       - For EIP-712: `{ domain, types, primaryType, message }` with full typed data
+     *       - For EIP-191: `{ message }` with plain text to sign
+     *
+     * **Output**: `SignMessageResponse`
+     *   - `v` (number): Signature v component
+     *   - `r` (string): Signature r component (hex string)
+     *   - `s` (string): Signature s component (hex string)
+     *   - `formattedSignature` (string): Complete signature string (hex)
+     *   - `type` (string): Always "evm"
+     *
+     * @param request - Message signing request with type and data
+     * @returns Promise resolving to SignMessageResponse with signature components
+     *
+     * @example
+     * ```typescript
+     * // EIP-191 simple message signing
+     * const signature = await agent.signMessage({
+     *   network: "ethereum:1",
+     *   request: {
+     *     messageType: "eip191",
+     *     data: { message: "Hello, world!" },
+     *     chainId: 1
+     *   }
+     * });
+     * console.log(`Signature: ${signature.formattedSignature}`);
+     *
+     * // EIP-712 typed data signing (for Polymarket orders, etc.)
+     * const typedSignature = await agent.signMessage({
+     *   network: "ethereum:137",
+     *   request: {
+     *     messageType: "eip712",
+     *     chainId: 137,
+     *     data: {
+     *       domain: { name: "MyApp", version: "1", chainId: 137 },
+     *       types: { Order: [{ name: "maker", type: "address" }] },
+     *       primaryType: "Order",
+     *       message: { maker: "0x..." }
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    signMessage(request: SignMessageRequest): Promise<SignMessageResponse>;
+    /**
+     * Access session-scoped key-value storage.
+     *
+     * Memory operations provide persistent storage for your agent session.
+     * All keys are automatically namespaced by agentId and sessionId.
+     */
+    readonly memory: {
+        /**
+         * Set a key-value pair in session memory.
+         *
+         * Store a string value with a unique key. The key is automatically scoped to your
+         * agent and session, so you don't need to worry about collisions.
+         *
+         * **Input**: `key: string, value: string`
+         *   - `key` (string): Unique identifier for the value (1-255 characters)
+         *   - `value` (string): String value to store
+         *
+         * **Output**: `MemorySetResponse`
+         *   - `success` (boolean): Whether the operation succeeded
+         *   - `data`: Present on success with the key that was set
+         *   - `error`: Error message on failure
+         *
+         * @param key - Unique identifier for the value (1-255 characters)
+         * @param value - String value to store
+         * @returns Promise resolving to MemorySetResponse with success status
+         *
+         * @example
+         * ```typescript
+         * const result = await agent.memory.set("lastSwapNetwork", "ethereum:42161");
+         * if (result.success && result.data) {
+         *   await agent.log(`Stored key: ${result.data.key}`);
+         * } else {
+         *   await agent.log(result.error || 'Failed to set memory', { error: true });
+         * }
+         * ```
+         */
+        set: (key: string, value: string) => Promise<MemorySetResponse>;
+        /**
+         * Get a value by key from session memory.
+         *
+         * Retrieve a previously stored value. Returns an error if the key doesn't exist.
+         *
+         * **Input**: `key: string`
+         *   - `key` (string): The key to retrieve
+         *
+         * **Output**: `MemoryGetResponse`
+         *   - `success` (boolean): Whether the operation succeeded
+         *   - `data`: Present on success with key and value
+         *   - `error`: Error message (e.g., "Key not found")
+         *
+         * @param key - The key to retrieve
+         * @returns Promise resolving to MemoryGetResponse with key and value or error
+         *
+         * @example
+         * ```typescript
+         * const result = await agent.memory.get("lastSwapNetwork");
+         * if (result.success && result.data) {
+         *   await agent.log(`Network: ${result.data.value}`);
+         * } else {
+         *   await agent.log(`Key not found: ${result.error}`, { error: true });
+         * }
+         * ```
+         */
+        get: (key: string) => Promise<MemoryGetResponse>;
+        /**
+         * Delete a key from session memory.
+         *
+         * Remove a key-value pair. Succeeds even if the key doesn't exist.
+         *
+         * **Input**: `key: string`
+         *   - `key` (string): The key to delete
+         *
+         * **Output**: `MemoryDeleteResponse`
+         *   - `success` (boolean): Whether the operation succeeded
+         *   - `data`: Present on success with the deleted key
+         *   - `error`: Error message on failure
+         *
+         * @param key - The key to delete
+         * @returns Promise resolving to MemoryDeleteResponse with success status
+         *
+         * @example
+         * ```typescript
+         * const result = await agent.memory.delete("tempSwapQuote");
+         * if (result.success && result.data) {
+         *   await agent.log(`Deleted key: ${result.data.key}`);
+         * }
+         * ```
+         */
+        delete: (key: string) => Promise<MemoryDeleteResponse>;
+        /**
+         * List all keys in session memory.
+         *
+         * Get an array of all keys stored for this agent session. Useful for debugging
+         * or iterating through stored data.
+         *
+         * **Input**: None
+         *
+         * **Output**: `MemoryListResponse`
+         *   - `success` (boolean): Whether the operation succeeded
+         *   - `data`: Present on success with keys array and count
+         *   - `error`: Error message on failure
+         *
+         * @returns Promise resolving to MemoryListResponse with array of keys
+         *
+         * @example
+         * ```typescript
+         * const result = await agent.memory.list();
+         * if (result.success && result.data) {
+         *   await agent.log(`Found ${result.data.count} keys:`);
+         *   for (const key of result.data.keys) {
+         *     await agent.log(`  - ${key}`);
+         *   }
+         * }
+         * ```
+         */
+        list: () => Promise<MemoryListResponse>;
+    };
+    /**
+     * Access platform integrations for trading and DeFi operations.
+     *
+     * Platform integrations provide seamless access to external services like
+     * prediction markets, lending protocols, and more.
+     */
+    readonly platforms: {
+        /**
+         * Access Polymarket prediction market trading operations.
+         *
+         * Note: Position data is available via agent.currentPositions in the request.
+         */
+        polymarket: {
+            /**
+             * Execute a market order on Polymarket.
+             *
+             * Places a buy or sell market order for the specified token and size. Handles approvals,
+             * signing, and submission automatically.
+             *
+             * ⚠️ **Important**: The `size` parameter meaning differs by order side:
+             * - **BUY**: `size` is the USD amount to spend (e.g., 10 = $10 worth of shares)
+             * - **SELL**: `size` is the number of shares/tokens to sell (e.g., 10 = 10 shares)
+             *
+             * **Input**: `PolymarketMarketOrderRequest`
+             *   - `tokenId` (string): Market token ID for the position
+             *   - `size` (number): For BUY: USD amount to spend. For SELL: Number of shares to sell
+             *   - `side` ("BUY" | "SELL"): Order side
+             *
+             * **Output**: `PolymarketMarketOrderResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data`: Market order data with orderInfo (orderId, side, priceUsd, txHashes)
+             *   - `error`: Error message on failure
+             *
+             * @param request - Order parameters (tokenId, size, side)
+             * @returns Promise resolving to PolymarketMarketOrderResponse with order details
+             *
+             * @example
+             * ```typescript
+             * // BUY order - size is USD amount
+             * const buyResult = await agent.platforms.polymarket.marketOrder({
+             *   tokenId: "123456",
+             *   size: 10,  // Spend $10 to buy shares
+             *   side: "BUY"
+             * });
+             *
+             * if (buyResult.success && buyResult.data) {
+             *   await agent.log(`Order ID: ${buyResult.data.orderInfo.orderId}`);
+             *   await agent.log(`Total: $${buyResult.data.orderInfo.totalPriceUsd}`);
+             * }
+             *
+             * // SELL order - size is number of shares
+             * const sellResult = await agent.platforms.polymarket.marketOrder({
+             *   tokenId: "123456",
+             *   size: 5,  // Sell 5 shares
+             *   side: "SELL"
+             * });
+             * ```
+             */
+            marketOrder: (request: PolymarketMarketOrderRequest) => Promise<PolymarketMarketOrderResponse>;
+            /**
+             * Redeem settled positions on Polymarket.
+             *
+             * Redeems one or all redeemable positions, claiming winnings. Handles multiple transactions if needed.
+             *
+             * **Input**: `PolymarketRedeemPositionsRequest` (optional)
+             *   - `tokenIds` (string[], optional): List of token IDs to redeem. Empty or omitted redeems all.
+             *
+             * **Output**: `PolymarketRedeemPositionsResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data`: Array of redemption results with position details and transaction hashes
+             *   - `error`: Error message on failure
+             *
+             * @param request - Redemption parameters (tokenIds list for specific positions, empty for all)
+             * @returns Promise resolving to PolymarketRedeemPositionsResponse with redemption results
+             *
+             * @example
+             * ```typescript
+             * // Redeem all positions
+             * const allResult = await agent.platforms.polymarket.redeemPositions();
+             *
+             * if (allResult.success && allResult.data) {
+             *   for (const tx of allResult.data) {
+             *     if (tx.success && tx.position) {
+             *       await agent.log(`Redeemed: ${tx.position.question}`);
+             *     }
+             *   }
+             * }
+             *
+             * // Redeem specific positions
+             * const specificResult = await agent.platforms.polymarket.redeemPositions({
+             *   tokenIds: ["123456", "789012"]
+             * });
+             * ```
+             */
+            redeemPositions: (request?: PolymarketRedeemPositionsRequest) => Promise<PolymarketRedeemPositionsResponse>;
+        };
+    };
+    /**
+     * Access cross-chain swap and bridge operations.
+     *
+     * Workflow: quote() -> execute(quote.data) -> check result.data.status
+     */
+    readonly swidge: {
+        /**
+         * Get a cross-chain swap or bridge quote.
+         *
+         * Get pricing and routing info for swapping tokens between networks or within the same network.
+         *
+         * **Input**: `SwidgeQuoteRequest`
+         *   - `from`: Source wallet `{ network, address }`
+         *   - `to`: Destination wallet `{ network, address }`
+         *   - `amount`: Amount in smallest unit (wei, lamports, etc.)
+         *   - `fromToken` (optional): Source token address (omit for native tokens)
+         *   - `toToken` (optional): Destination token address (omit for native tokens)
+         *   - `slippage` (optional): Slippage tolerance % as string (default: "0.5")
+         *   - `priceImpact` (optional): Max price impact % as string (default: "0.5")
+         *
+         * **Output**: `SwidgeQuoteResponse`
+         *   - `success`: Whether the quote was retrieved successfully
+         *   - `data`: Quote data with asset details, fees, and steps
+         *   - `error`: Error message if quote failed
+         *
+         * @param request - Quote parameters with wallet info, amount, and optional tokens/slippage
+         * @returns Promise resolving to SwidgeQuoteResponse with pricing and transaction steps
+         *
+         * @example
+         * ```typescript
+         * const quote = await agent.swidge.quote({
+         *   from: { network: "ethereum:1", address: agent.sessionWalletAddress },
+         *   to: { network: "ethereum:42161", address: agent.sessionWalletAddress },
+         *   amount: "1000000000000000000",  // 1 ETH
+         *   toToken: "0x2f2a2543B76A4166549F7aaB2e75BEF0aefC5b0f"  // WBTC
+         * });
+         *
+         * if (quote.success && quote.data) {
+         *   await agent.log(`You'll receive: ${quote.data.assetReceive.amountFormatted}`);
+         * }
+         * ```
+         */
+        quote: (request: SwidgeQuoteRequest) => Promise<SwidgeQuoteResponse>;
+        /**
+         * Execute a cross-chain swap or bridge using a quote.
+         *
+         * Takes your quote and signs/broadcasts transactions automatically.
+         *
+         * **Input**: `SwidgeQuoteData` - Complete quote object from agent.swidge.quote()
+         *
+         * **Output**: `SwidgeExecuteResponse`
+         *   - `success`: Whether the execution was successful
+         *   - `data`: Execution result with status ("success", "failure", "refund", "delayed") and transaction hashes
+         *   - `error`: Error message if execution failed
+         *
+         * @param quoteData - Complete quote object from agent.swidge.quote()
+         * @returns Promise resolving to SwidgeExecuteResponse with transaction status
+         *
+         * @example
+         * ```typescript
+         * const quote = await agent.swidge.quote({...});
+         * if (quote.success && quote.data) {
+         *   const result = await agent.swidge.execute(quote.data);
+         *   if (result.success && result.data) {
+         *     await agent.log(`Swap status: ${result.data.status}`);
+         *     if (result.data.status === "success") {
+         *       await agent.log(`Tx hash: ${result.data.out.txs[0]}`);
+         *     }
+         *   }
+         * }
+         * ```
+         */
+        execute: (quoteData: SwidgeQuoteData) => Promise<SwidgeExecuteResponse>;
+    };
+}
+
 /**
- * Contract for agent stop/winddown function. Called to gracefully shut down and
- * run cleanup logic (e.g. withdrawing positions, updating schedules).
- * @param request - Contains session information and wallet address to operate with
- * @returns Promise resolving to a success/error response
+ * Contract for agent execution functions. Called to perform the agent's main task.
+ *
+ * Your execution function receives an AgentContext with all request data and SDK methods.
+ * Simply perform your agent logic and return nothing - errors are caught automatically.
+ *
+ * @param agent - AgentContext with session data and SDK methods
+ * @returns Promise that resolves when execution is complete (returns void)
+ *
  * @example
  * ```typescript
- * // Winddown function implementation
- * const stopFunction: StopFunctionContract = async (request) => {
- *   const agentToolset = new AgentToolset({ sessionId: request.sessionId });
- *
- *   try {
- *     // Notify about shutdown
- *     await agentToolset.sendLog([{
- *       type: "observe",
- *       shortMessage: "Agent shutting down...",
- *     }]);
+ * async function execution_function(agent: AgentContext): Promise<void> {
+ *   await agent.log(`Starting execution for session ${agent.sessionId}`);
  *
- *     // Example: Update sleep interval before shutdown
- *     await agentToolset.sessionUpdateSleepInterval({
- *       sleepMinutes: 60 // Set longer interval during inactive period
- *     });
+ *   // Use SDK methods directly
+ *   await agent.memory.set("last_run", Date.now().toString());
  *
- *     // Example: Final status message
- *     await agentToolset.sendLog([{
- *       type: "observe",
- *       shortMessage: "Shutdown complete",
- *     }]);
+ *   // Check positions from request
+ *   await agent.log(`Managing ${agent.currentPositions.length} positions`);
  *
- *     return {
- *       success: true,
- *       message: "Agent stopped successfully"
- *     };
- *   } catch (error) {
- *     return {
- *       success: false,
- *       error: error instanceof Error ? error.message : "Failed to clean up",
- *       message: "Stop operation failed"
- *     };
+ *   // Error handling pattern
+ *   const result = await agent.memory.get("settings");
+ *   if (!result.success) {
+ *     await agent.log(result.error || 'Failed to get settings', { error: true });
+ *     return;
  *   }
- * };
+ *
+ *   // Errors thrown here are caught automatically
+ * }
  * ```
  */
-type StopFunctionContract = (request: AgentRequest) => Promise<AgentResponse>;
+type runFunctionContract = (agent: AgentContext) => Promise<void>;
 /**
- * Contract for agent health check functions. Handle health status requests.
- * @returns Promise resolving to an object with a status field
+ * Contract for agent stop/winddown function. Called to gracefully shut down and
+ * run cleanup logic (e.g. redeeming positions, final logging).
+ *
+ * @param agent - AgentContext with session data and SDK methods
+ * @returns Promise that resolves when stop is complete (returns void)
+ *
  * @example
  * ```typescript
- * // Health check function implementation
- * const healthCheckFunction: HealthCheckFunctionContract = async () => {
- *   // Check database connection, external services, etc.
- *   const isHealthy = await checkSystemHealth();
+ * async function stop_function(agent: AgentContext): Promise<void> {
+ *   await agent.log("Cleaning up...");
  *
- *   return {
- *     status: isHealthy ? "healthy" : "unhealthy",
- *     // Optional additional fields
- *     uptime: process.uptime(),
- *     timestamp: new Date().toISOString()
- *   };
- * };
+ *   // Redeem positions from request
+ *   if (agent.currentPositions.length > 0) {
+ *     const redemption = await agent.platforms.polymarket.redeemPositions();
+ *     if (!redemption.success) {
+ *       await agent.log(redemption.error || 'Redemption failed', { error: true });
+ *     }
+ *   }
+ * }
  * ```
  */
-type HealthCheckFunctionContract = () => Promise<HealthResponse>;
+type StopFunctionContract = (agent: AgentContext) => Promise<void>;
 /**
  * Configuration object for creating a new agent
  */
 interface AgentConfig {
     /** Main execution function that implements the agent's core logic */
-    executionFunction: ExecutionFunctionContract;
+    runFunction: runFunctionContract;
     /** Optional winddown function for cleanup operations, this is called when the agent is stopped */
     stopFunction?: StopFunctionContract;
-    /** Optional health check function for monitoring agent health status */
-    healthCheckFunction?: HealthCheckFunctionContract;
 }
 /**
  * HTTP server wrapper for agent functions.
@@ -1496,16 +2065,16 @@ interface AgentConfig {
  * Exposes the following endpoints:
  * - `POST /execute` — required, calls your execution function
  * - `POST /stop` — always available, uses provided or default stop function
- * - `GET /health` — always available, uses provided or default health check
+ * - `GET /health` — always available, uses default health check
  */
 declare class Agent {
     private app;
-    private executionFunction;
+    private runFunction;
     private stopFunction?;
-    private healthCheckFunction?;
+    private readonly healthCheckFunction;
     /**
      * Create a new `Agent` with the provided handlers.
-     * @param config - Execution function is required; chat/stop/health are optional.
+     * @param config - Execution function is required; stop function is optional.
      */
     constructor(config: AgentConfig);
     /**
@@ -1514,10 +2083,25 @@ declare class Agent {
     private defaultStopFunction;
     /**
      * Execute a function with automatic job status tracking.
+     *
+     * Creates AgentContext from request, executes the function, and handles errors automatically.
+     * Uses finally block to guarantee status update even if errors occur.
      */
     private executeWithJobTracking;
     /**
-     * Update job status using the AgentSdk.
+     * Safely extract error message from exception with guaranteed fallback.
+     * This method NEVER throws - always returns a valid string.
+     */
+    private getErrorMessage;
+    /**
+     * Update job status with retries and fallback. NEVER throws exceptions.
+     *
+     * Strategy:
+     * 1. Try to send status with error message (3 retries with exponential backoff)
+     * 2. If that fails, try to send status WITHOUT error message (final fallback)
+     *
+     * This ensures the job status is ALWAYS updated, even if the error message
+     * causes issues or the API is temporarily unavailable.
      */
     private updateJobStatus;
     private setupRoutes;
@@ -1526,7 +2110,7 @@ declare class Agent {
         fetch: (request: Request, env: any, ctx: any) => Promise<Response>;
     } | undefined;
     /** Get the worker export for Cloudflare Workers environments. */
-    getWorkerExport(): {
+    getExport(): {
         fetch: (request: Request, env: any, ctx: any) => Promise<Response>;
     };
 }
@@ -1554,4 +2138,4 @@ declare function isSolanaNetwork(network: Network): network is "solana";
  */
 declare function getChainIdFromNetwork(network: `ethereum:${number}`): number;
 
-export { APIClient, Agent, AgentSdk, type ExecutionFunctionContract, type MemoryDeleteRequest, type MemoryDeleteResponse, type MemoryGetRequest, type MemoryGetResponse, type MemoryListRequest, type MemoryListResponse, type MemorySetRequest, type MemorySetResponse, type Network, type PolymarketMarketOrderRequest, type PolymarketMarketOrderResponse, type PolymarketPosition, type PolymarketPositionsResponse, type PolymarketRedeemPositionsRequest, type PolymarketRedeemPositionsResponse, QUOTE_RESULT, type SDKConfig, type SignAndSendRequest, type SignAndSendResponse, type SignMessageRequest, type SignMessageResponse, type StopFunctionContract, type SwidgeExecuteResponse, type SwidgeQuoteRequest, type SwidgeQuoteResponse, type SwidgeQuoteResult, getChainIdFromNetwork, isEthereumNetwork, isSolanaNetwork };
+export { APIClient, Agent, AgentContext, AgentSdk, type CurrentPosition, type LogResponse, type MemoryDeleteResponse, type MemoryGetResponse, type MemoryListResponse, type MemorySetResponse, type Network, type PolymarketMarketOrderRequest, type PolymarketMarketOrderResponse, type PolymarketRedeemPositionsRequest, type PolymarketRedeemPositionsResponse, QUOTE_RESULT, type SDKConfig, type SignAndSendRequest, type SignAndSendResponse, type SignMessageRequest, type SignMessageResponse, type StopFunctionContract, type SwidgeExecuteResponse, type SwidgeQuoteRequest, type SwidgeQuoteResponse, type SwidgeQuoteResult, getChainIdFromNetwork, isEthereumNetwork, isSolanaNetwork, type runFunctionContract };