@stacknet/stacks 0.1.0

package/dist/streaming/index.d.cts

@@ -0,0 +1,145 @@
+/**
+ * SSE (Server-Sent Events) streaming utilities
+ */
+interface SSEEvent {
+    event?: string;
+    data: unknown;
+    id?: string;
+    retry?: number;
+}
+/**
+ * Parse SSE stream from a Response
+ */
+declare function parseSSEStream(response: Response): AsyncIterable<SSEEvent>;
+/**
+ * Create an SSE Response from an async iterable
+ */
+declare function createSSEResponse(stream: AsyncIterable<SSEEvent>, headers?: Record<string, string>): Response;
+/**
+ * Create an SSE writer for streaming events
+ */
+declare class SSEWriter {
+    private encoder;
+    private controller;
+    private stream;
+    constructor();
+    /**
+     * Get the underlying ReadableStream
+     */
+    getStream(): ReadableStream<Uint8Array>;
+    /**
+     * Get a Response object for this stream
+     */
+    getResponse(headers?: Record<string, string>): Response;
+    /**
+     * Write an SSE event
+     */
+    write(event: SSEEvent): void;
+    /**
+     * Write a data-only event
+     */
+    writeData(data: unknown): void;
+    /**
+     * Write a comment (for keep-alive)
+     */
+    writeComment(comment: string): void;
+    /**
+     * Close the stream
+     */
+    close(): void;
+    /**
+     * Signal an error
+     */
+    error(err: Error): void;
+}
+/**
+ * Create an SSE writer
+ */
+declare function createSSEWriter(): SSEWriter;
+
+/**
+ * Component Streaming - Artifact streaming adapter
+ *
+ * Converts tool call responses to artifact data stream format
+ */
+interface DataStreamWriter {
+    write(data: {
+        type: string;
+        data: unknown;
+        transient?: boolean;
+    }): void;
+}
+interface ArtifactToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ArtifactToolResult {
+    type: string;
+    id?: string;
+    title?: string;
+    kind?: string;
+    content?: string;
+    message?: string;
+    [key: string]: unknown;
+}
+/**
+ * Artifact streaming adapter for AI SDK integration
+ */
+declare class ComponentStreamAdapter {
+    private dataStream;
+    constructor(dataStream: DataStreamWriter);
+    /**
+     * Process tool calls and convert to artifact stream events
+     */
+    processToolCalls(toolCalls: ArtifactToolCall[]): void;
+    /**
+     * Process tool results
+     */
+    processToolResult(result: ArtifactToolResult): void;
+    /**
+     * Stream an artifact with metadata
+     */
+    streamArtifact(artifact: {
+        id: string;
+        kind: string;
+        title: string;
+        content: string;
+    }): void;
+    /**
+     * Stream a text delta
+     */
+    streamTextDelta(delta: string): void;
+    /**
+     * Stream content in chunks
+     */
+    streamContent(content: string, chunkSize?: number): void;
+    /**
+     * Signal finish
+     */
+    finish(): void;
+    private handleCreateDocument;
+    private handleUpdateDocument;
+    private handleArtifactResult;
+    private handleArtifactUpdate;
+    private splitIntoChunks;
+}
+/**
+ * Helper to detect tool calls in a message
+ */
+declare function hasToolCalls(message: {
+    tool_calls?: unknown[];
+}): boolean;
+/**
+ * Helper to extract tool results from content
+ */
+declare function extractToolResults(content: string): ArtifactToolResult[];
+/**
+ * Factory function
+ */
+declare function createComponentStreamAdapter(dataStream: DataStreamWriter): ComponentStreamAdapter;
+
+export { type ArtifactToolCall, type ArtifactToolResult, ComponentStreamAdapter, type DataStreamWriter, type SSEEvent, SSEWriter, createComponentStreamAdapter, createSSEResponse, createSSEWriter, extractToolResults, hasToolCalls, parseSSEStream };

package/dist/streaming/index.d.ts

@@ -0,0 +1,145 @@
+/**
+ * SSE (Server-Sent Events) streaming utilities
+ */
+interface SSEEvent {
+    event?: string;
+    data: unknown;
+    id?: string;
+    retry?: number;
+}
+/**
+ * Parse SSE stream from a Response
+ */
+declare function parseSSEStream(response: Response): AsyncIterable<SSEEvent>;
+/**
+ * Create an SSE Response from an async iterable
+ */
+declare function createSSEResponse(stream: AsyncIterable<SSEEvent>, headers?: Record<string, string>): Response;
+/**
+ * Create an SSE writer for streaming events
+ */
+declare class SSEWriter {
+    private encoder;
+    private controller;
+    private stream;
+    constructor();
+    /**
+     * Get the underlying ReadableStream
+     */
+    getStream(): ReadableStream<Uint8Array>;
+    /**
+     * Get a Response object for this stream
+     */
+    getResponse(headers?: Record<string, string>): Response;
+    /**
+     * Write an SSE event
+     */
+    write(event: SSEEvent): void;
+    /**
+     * Write a data-only event
+     */
+    writeData(data: unknown): void;
+    /**
+     * Write a comment (for keep-alive)
+     */
+    writeComment(comment: string): void;
+    /**
+     * Close the stream
+     */
+    close(): void;
+    /**
+     * Signal an error
+     */
+    error(err: Error): void;
+}
+/**
+ * Create an SSE writer
+ */
+declare function createSSEWriter(): SSEWriter;
+
+/**
+ * Component Streaming - Artifact streaming adapter
+ *
+ * Converts tool call responses to artifact data stream format
+ */
+interface DataStreamWriter {
+    write(data: {
+        type: string;
+        data: unknown;
+        transient?: boolean;
+    }): void;
+}
+interface ArtifactToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ArtifactToolResult {
+    type: string;
+    id?: string;
+    title?: string;
+    kind?: string;
+    content?: string;
+    message?: string;
+    [key: string]: unknown;
+}
+/**
+ * Artifact streaming adapter for AI SDK integration
+ */
+declare class ComponentStreamAdapter {
+    private dataStream;
+    constructor(dataStream: DataStreamWriter);
+    /**
+     * Process tool calls and convert to artifact stream events
+     */
+    processToolCalls(toolCalls: ArtifactToolCall[]): void;
+    /**
+     * Process tool results
+     */
+    processToolResult(result: ArtifactToolResult): void;
+    /**
+     * Stream an artifact with metadata
+     */
+    streamArtifact(artifact: {
+        id: string;
+        kind: string;
+        title: string;
+        content: string;
+    }): void;
+    /**
+     * Stream a text delta
+     */
+    streamTextDelta(delta: string): void;
+    /**
+     * Stream content in chunks
+     */
+    streamContent(content: string, chunkSize?: number): void;
+    /**
+     * Signal finish
+     */
+    finish(): void;
+    private handleCreateDocument;
+    private handleUpdateDocument;
+    private handleArtifactResult;
+    private handleArtifactUpdate;
+    private splitIntoChunks;
+}
+/**
+ * Helper to detect tool calls in a message
+ */
+declare function hasToolCalls(message: {
+    tool_calls?: unknown[];
+}): boolean;
+/**
+ * Helper to extract tool results from content
+ */
+declare function extractToolResults(content: string): ArtifactToolResult[];
+/**
+ * Factory function
+ */
+declare function createComponentStreamAdapter(dataStream: DataStreamWriter): ComponentStreamAdapter;
+
+export { type ArtifactToolCall, type ArtifactToolResult, ComponentStreamAdapter, type DataStreamWriter, type SSEEvent, SSEWriter, createComponentStreamAdapter, createSSEResponse, createSSEWriter, extractToolResults, hasToolCalls, parseSSEStream };

package/dist/streaming/index.js

@@ -0,0 +1,13 @@
+var m={"Content-Type":"text/event-stream","Cache-Control":"no-cache",Connection:"keep-alive"};async function*S(i){if(!i.body)throw new Error("Response body is null");let t=i.body.getReader(),r=new TextDecoder,n="",e={};try{for(;;){let{done:a,value:o}=await t.read();if(a)break;n+=r.decode(o,{stream:!0});let s=n.split(`
+`);n=s.pop()||"";for(let c of s){if(c===""){e.data!==void 0&&(yield e),e={};continue}if(c.startsWith(":"))continue;let u=c.indexOf(":");if(u===-1)continue;let f=c.slice(0,u),l=c.slice(u+1).trimStart();switch(f){case "event":e.event=l;break;case "data":try{e.data=JSON.parse(l);}catch{e.data=l;}break;case "id":e.id=l;break;case "retry":e.retry=parseInt(l,10);break}}}e.data!==void 0&&(yield e);}finally{t.releaseLock();}}function h(i,t){let r=new TextEncoder,n=new ReadableStream({async start(e){try{for await(let a of i){let o="";a.event&&(o+=`event: ${a.event}
+`),a.id&&(o+=`id: ${a.id}
+`),a.retry&&(o+=`retry: ${a.retry}
+`);let s=typeof a.data=="string"?a.data:JSON.stringify(a.data);o+=`data: ${s}
+
+`,e.enqueue(r.encode(o));}}catch(a){console.error("SSE stream error:",a);}finally{e.close();}}});return new Response(n,{headers:{...m,...t}})}var d=class{encoder=new TextEncoder;controller=null;stream;constructor(){this.stream=new ReadableStream({start:t=>{this.controller=t;}});}getStream(){return this.stream}getResponse(t){return new Response(this.stream,{headers:{...m,...t}})}write(t){if(!this.controller)return;let r="";t.event&&(r+=`event: ${t.event}
+`),t.id&&(r+=`id: ${t.id}
+`);let n=typeof t.data=="string"?t.data:JSON.stringify(t.data);r+=`data: ${n}
+
+`,this.controller.enqueue(this.encoder.encode(r));}writeData(t){this.write({data:t});}writeComment(t){this.controller&&this.controller.enqueue(this.encoder.encode(`: ${t}
+
+`));}close(){this.controller&&(this.controller.close(),this.controller=null);}error(t){this.controller&&(this.controller.error(t),this.controller=null);}};function g(){return new d}var p=class{constructor(t){this.dataStream=t;}processToolCalls(t){if(!(!t||t.length===0))for(let r of t)try{let n=JSON.parse(r.function.arguments),e=r.function.name;switch(e){case "create_document":this.handleCreateDocument(n,r.id);break;case "update_document":this.handleUpdateDocument(n,r.id);break;default:console.log(`[ComponentStream] Unknown tool: ${e}`);}}catch(n){console.error("[ComponentStream] Error processing tool call:",n);}}processToolResult(t){try{t.type==="artifact"?this.handleArtifactResult(t):t.type==="artifact_update"&&this.handleArtifactUpdate(t);}catch(r){console.error("[ComponentStream] Error processing tool result:",r);}}streamArtifact(t){this.dataStream.write({type:"data-kind",data:t.kind,transient:true}),this.dataStream.write({type:"data-id",data:t.id,transient:true}),this.dataStream.write({type:"data-title",data:t.title,transient:true}),this.dataStream.write({type:"data-clear",data:null,transient:true}),this.streamContent(t.content),this.dataStream.write({type:"data-finish",data:null,transient:true});}streamTextDelta(t){this.dataStream.write({type:"data-textDelta",data:t,transient:true});}streamContent(t,r=50){let n=this.splitIntoChunks(t,r);for(let e of n)this.dataStream.write({type:"data-textDelta",data:e,transient:true});}finish(){this.dataStream.write({type:"data-finish",data:null,transient:true});}handleCreateDocument(t,r){let{title:n,kind:e,content:a}=t,o=`doc_${Date.now()}_${Math.random().toString(36).substr(2,9)}`;console.log(`[ComponentStream] Creating document: ${n} (${e})`),this.streamArtifact({id:o,kind:e,title:n,content:a}),this.dataStream.write({type:"tool-result",data:{toolCallId:r,toolName:"create_document",result:{id:o,title:n,kind:e,message:"Document created successfully"}}});}handleUpdateDocument(t,r){let{id:n,description:e,content:a}=t;console.log(`[ComponentStream] Updating document: ${n}`),this.dataStream.write({type:"data-clear",data:null,transient:true}),this.streamContent(a),this.dataStream.write({type:"data-finish",data:null,transient:true}),this.dataStream.write({type:"tool-result",data:{toolCallId:r,toolName:"update_document",result:{id:n,message:`Document updated: ${e}`}}});}handleArtifactResult(t){let{id:r,title:n,kind:e,content:a}=t;if(!r||!n||!e||!a){console.error("[ComponentStream] Invalid artifact result:",t);return}this.streamArtifact({id:r,kind:e,title:n,content:a});}handleArtifactUpdate(t){let{content:r}=t;if(!r){console.error("[ComponentStream] Invalid artifact update:",t);return}this.dataStream.write({type:"data-clear",data:null,transient:true}),this.streamContent(r),this.dataStream.write({type:"data-finish",data:null,transient:true});}splitIntoChunks(t,r){let n=[],e=t.split(" "),a="";for(let o=0;o<e.length;o++){let s=o===0?e[o]:" "+e[o];a.length+s.length>r&&a.length>0?(n.push(a),a=s.trim()):a+=s;}return a.length>0&&n.push(a),n}};function y(i){return !!(i?.tool_calls&&Array.isArray(i.tool_calls)&&i.tool_calls.length>0)}function E(i){try{let t=JSON.parse(i);if(t.type&&(t.type==="artifact"||t.type==="artifact_update"))return [t]}catch{}return []}function v(i){return new p(i)}export{p as ComponentStreamAdapter,d as SSEWriter,v as createComponentStreamAdapter,h as createSSEResponse,g as createSSEWriter,E as extractToolResults,y as hasToolCalls,S as parseSSEStream};

package/dist/types/index.cjs

@@ -0,0 +1 @@
+'use strict';var o={text_input:1,image_input:2,file_input:4,audio_input:8,video_input:16,music_input:32,text_output:64,image_output:128,audio_output:256,video_output:512,embeddings_output:1024,music_output:2048,skills:4096,loops:8192,tools:16384,pipelines:32768,training:65536},n=131071;function a(t){let e=0;for(let[i,r]of Object.entries(o))t[i]&&(e|=r);return e}function s(t){let e={};for(let[i,r]of Object.entries(o))e[i]=(t&r)!==0;return e}exports.ALL_CAPABILITIES_BITMASK=n;exports.CAPABILITY_BITS=o;exports.bitmaskToCapabilities=s;exports.capabilitiesToBitmask=a;

package/dist/types/index.d.cts

@@ -0,0 +1,335 @@
+export { A as ALL_CAPABILITIES_BITMASK, c as ActionProof, d as AddPointsInput, e as Agent, f as AgentCreateInput, g as AgentExecuteRequest, h as AgentExecuteResponse, i as AgentFromPromptInput, j as AgentResponse, k as AgentTrigger, l as AgentUpdateInput, m as AgentWorkflow, n as AgentWorkflowEdge, o as AgentWorkflowNode, p as AgentsClientConfig, q as AgentsListResponse, r as AllowlistConfig, s as AllowlistMode, t as AllowlistUpdateInput, u as AuthMetrics, B as BillingClientConfig, v as BillingPlan, w as BillingPlansResponse, x as BillingPortalResponse, y as BillingState, z as BillingTier, C as CAPABILITY_BITS, D as CapabilityKey, E as ChatCompletionChunk, F as ChatCompletionRequest, G as ChatCompletionResponse, H as CommentResponse, I as CommentsResponse, J as ConfigureOAuthInput, K as ConfigureStripeInput, L as ConfigureWeb3Input, M as ConsensusStateSummary, N as ConsensusStatus, O as ContextDomain, P as ContextResponse, Q as ContextsListResponse, R as CreateCheckoutSessionResponse, S as CreateContextInput, U as CreateDelegationInput, V as CreateDomainInput, W as CreateKeyResponse, X as CreatePostInput, Y as CreatePostResponse, Z as CreateStackRequest, _ as Delegation, $ as DelegationChainLink, a0 as DelegationFilters, a1 as DelegationResponse, a2 as DelegationScope, a3 as DelegationsListResponse, a4 as DomainResponse, a5 as DomainsListResponse, a6 as FeedResponse, a7 as FileUploadResponse, a8 as FilesClientConfig, a9 as HistoryFilters, aa as HistoryResponse, ab as ImaginationCharacter, ac as ImaginationMetadata, ad as ImaginationSource, ae as InitNetworkResponse, af as LeaderStatus, ag as LikeCheckResponse, ah as LikeResponse, ai as MCPContent, aj as MCPMessage, ak as MCPSession, al as MCPSessionConfig, am as MCPToolResult, an as MPCNode, ao as MagmaFile, ap as MediaType, aq as Message, ar as MeteredUsage, as as ModelLayerInfo, at as ModelLayersResponse, au as NetworkClientConfig, av as NetworkStatus, br as Orientation, aw as PaginationMeta, ax as PaymentRequiredResponse, ay as PointBalance, az as PointContext, aA as PointRecord, aB as PointRecordResponse, aC as PointSpend, aD as PointSpendResponse, aE as PointsClientConfig, aF as PostResponse, aG as ProfileResponse, aH as RemixesResponse, aI as Skill, aJ as SkillCreateInput, bp as SkillMapPromptResponse, bo as SkillMapResponse, aK as SkillResponse, bq as SkillSummaryResponse, aL as SkillUpdateInput, bn as SkillVerifyResponse, aM as SkillsClientConfig, aN as SkillsListResponse, aO as SocialAuthor, aP as SocialClientConfig, aQ as SocialComment, aR as SocialPost, aS as SocialRemix, aT as SpendDestination, aU as SpendPointsInput, aV as StackCapabilities, aW as StackConfig, aX as StackKeyInfo, aY as StackKeysListResponse, aZ as StackListResponse, a_ as StackManagementClientConfig, a$ as StackMember, b0 as StackMemberStats, b1 as StackModelAlias, b2 as StackOAuthProvider, b3 as StackResponse, b4 as StackStripeProvider, b5 as StackWeb3Provider, b6 as TaskPayload, b7 as TaskResponse, a as TaskState, b as TaskStatus, T as TaskType, b8 as UsageRecord, b9 as UserClientConfig, ba as UserProfile, bb as UserProfileResponse, bc as UserProfileUpdateInput, bd as Widget, be as WidgetCreateInput, bf as WidgetResponse, bg as WidgetSystemPromptResponse, bh as WidgetUpdateInput, bi as WidgetsClientConfig, bj as WidgetsListResponse, bk as WorkflowData, bl as bitmaskToCapabilities, bm as capabilitiesToBitmask } from '../billing-BaJlf_S8.cjs';
+
+/**
+ * Coder type definitions
+ * Types for the GeoffCoder AI coding agent
+ */
+type CoderSessionStatus = 'active' | 'completed' | 'aborted' | 'error';
+interface CoderSession {
+    id: string;
+    workingDirectory: string;
+    status: CoderSessionStatus;
+    createdAt: string;
+    updatedAt?: string;
+    metrics: CoderMetrics;
+    sandboxId?: string;
+}
+interface CoderMetrics {
+    tokensUsed: number;
+    promptTokens: number;
+    completionTokens: number;
+    contextSize: number;
+    filesCreated: number;
+    filesModified: number;
+    linesAdded: number;
+    linesRemoved: number;
+    commandsExecuted: number;
+    toolCallsTotal: number;
+    apiCalls: number;
+    startTime: number;
+    endTime?: number;
+    modifiedFiles: string[];
+    createdFiles: string[];
+}
+interface CoderExecuteRequest {
+    /** The prompt/task for the coder agent */
+    prompt: string;
+    /** Working directory for file operations */
+    workingDirectory?: string;
+    /** Maximum iterations for the agent loop */
+    maxIterations?: number;
+    /** Model to use for completions */
+    model?: string;
+    /** Maximum tokens per response */
+    maxTokens?: number;
+    /** Temperature for generation */
+    temperature?: number;
+    /** Whether to stream the response */
+    stream?: boolean;
+    /** Existing session ID to continue */
+    sessionId?: string;
+    /** Existing sandbox ID to use (from frontend) */
+    sandboxId?: string;
+    /** E2B sandbox configuration */
+    sandbox?: CoderSandboxConfig;
+    /** Chat ID for session tracking and approval responses */
+    chatId?: string;
+    /** API base URL for self-hosted inference endpoint */
+    apiBase?: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** Auto-approve tool execution (default: true for backward compatibility) */
+    autoApprove?: boolean;
+    /** Tool permission overrides */
+    toolPermissions?: Record<string, {
+        permission: 'always' | 'ask' | 'never';
+        allowlist?: string[];
+        denylist?: string[];
+    }>;
+}
+interface CoderSandboxConfig {
+    /** Enable sandbox execution */
+    enabled: boolean;
+    /** Sandbox template (e.g., 'node', 'python', 'nextjs') */
+    template?: string;
+    /** Session timeout in seconds */
+    timeout?: number;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Packages to pre-install */
+    packages?: string[];
+}
+interface CoderExecuteResponse {
+    sessionId: string;
+    status: CoderSessionStatus;
+    result?: string;
+    error?: string;
+    metrics: CoderMetrics;
+}
+type CoderStreamEventType = 'session_start' | 'thinking' | 'tool_call' | 'tool_result' | 'assistant_message' | 'progress' | 'metrics_update' | 'session_complete' | 'complete' | 'file_written' | 'file_modified' | 'sandbox_info' | 'session_files' | 'text' | 'done' | 'error' | 'approval_required' | 'approval_response' | 'tool_blocked' | 'context_compacted' | 'background_process_started' | 'background_process_completed' | 'session_saved' | 'session_resumed' | 'file_checkpoint' | 'memory_loaded' | 'question_asked' | 'question_answered' | 'blueprint_generated' | 'plan_progress' | 'token_usage' | 'task_created' | 'task_update';
+interface CoderStreamEvent {
+    type: CoderStreamEventType;
+    data: unknown;
+    timestamp: number;
+}
+interface CoderThinkingEvent {
+    type: 'thinking';
+    data: {
+        content: string;
+        iteration: number;
+    };
+}
+interface CoderToolCallEvent {
+    type: 'tool_call';
+    data: {
+        toolName: string;
+        arguments: Record<string, unknown>;
+        toolCallId: string;
+    };
+}
+interface CoderToolResultEvent {
+    type: 'tool_result';
+    data: {
+        toolCallId: string;
+        toolName: string;
+        success: boolean;
+        output: string;
+        error?: string;
+    };
+}
+interface CoderProgressEvent {
+    type: 'progress';
+    data: {
+        iteration: number;
+        maxIterations: number;
+        currentAction: string;
+    };
+}
+interface CoderTool {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, CoderToolParameter>;
+        required?: string[];
+    };
+}
+interface CoderToolParameter {
+    type: string;
+    description: string;
+    enum?: string[];
+}
+interface CoderToolResult {
+    success: boolean;
+    output: string;
+    error?: string;
+}
+interface CoderFileInfo {
+    name: string;
+    path: string;
+    size: number;
+    isDirectory: boolean;
+    modified?: string;
+    children?: CoderFileInfo[];
+}
+interface CoderFileContent {
+    path: string;
+    content: string;
+    encoding?: 'utf8' | 'base64';
+    size: number;
+}
+interface CoderFileWriteInput {
+    path: string;
+    content: string;
+    encoding?: 'utf8' | 'base64';
+    createDirectories?: boolean;
+}
+interface CoderSearchResult {
+    file: string;
+    line: number;
+    content: string;
+    contextBefore?: string[];
+    contextAfter?: string[];
+}
+interface CoderDiffInput {
+    path: string;
+    original: string;
+    replacement: string;
+    replaceAll?: boolean;
+}
+interface CoderCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    executionTimeMs: number;
+}
+interface CoderCommandInput {
+    command: string;
+    timeout?: number;
+    cwd?: string;
+}
+interface CoderSandbox {
+    id: string;
+    status: 'creating' | 'ready' | 'busy' | 'stopped' | 'error';
+    template: string;
+    workingDirectory: string;
+    createdAt: string;
+    expiresAt?: string;
+}
+interface CoderSandboxCreateInput {
+    template?: string;
+    timeout?: number;
+    env?: Record<string, string>;
+    packages?: string[];
+}
+interface CoderSandboxExecInput {
+    command: string;
+    timeout?: number;
+    stream?: boolean;
+}
+interface CoderSandboxExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    executionTimeMs: number;
+}
+interface CoderSessionResponse {
+    session: CoderSession;
+}
+interface CoderSessionsListResponse {
+    sessions: CoderSession[];
+}
+interface CoderToolsResponse {
+    tools: CoderTool[];
+}
+interface CoderFilesResponse {
+    files: CoderFileInfo[];
+    path: string;
+}
+interface CoderSandboxResponse {
+    sandbox: CoderSandbox;
+}
+interface CoderClientConfig {
+    /** Base URL for the task network API */
+    baseUrl?: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Default model for coder sessions */
+    defaultModel?: string;
+    /** Default max iterations */
+    defaultMaxIterations?: number;
+}
+
+/**
+ * Credential and identity type definitions
+ */
+type AuthMethod = 'email' | 'web3_evm' | 'web3_solana' | 'web3_bitcoin' | 'web3_cosmos' | 'oauth_google' | 'oauth_github' | 'oauth_discord' | 'oauth_twitter';
+type Web3Chain = 'ethereum' | 'solana' | 'bitcoin' | 'cosmos' | 'polygon' | 'arbitrum' | 'base';
+type CredentialType = 'email' | 'web3_wallet' | 'oauth_social' | 'billing_stripe' | 'stripe_connect';
+interface StackCredential {
+    id: string;
+    stack_identity_id: string;
+    credential_type: CredentialType;
+    credential_data: EmailCredentialData | Web3CredentialData | OAuthCredentialData | BillingCredentialData | StripeConnectCredentialData;
+    is_primary: boolean;
+    linked_at: number;
+}
+interface EmailCredentialData {
+    email_hash: string;
+    verified: boolean;
+    verified_at?: number;
+}
+interface Web3CredentialData {
+    chain: Web3Chain;
+    address: string;
+    address_type: 'p2wpkh' | 'p2tr' | 'ed25519' | 'secp256k1';
+    verification_signature: string;
+    verified_at: number;
+}
+interface OAuthCredentialData {
+    provider: 'google' | 'github' | 'discord' | 'twitter';
+    provider_user_id: string;
+    handle?: string;
+    verified_at: number;
+}
+interface BillingCredentialData {
+    provider: 'stripe';
+    customer_id: string;
+    has_payment_method: boolean;
+    default_payment_method_id?: string;
+    card_last_four?: string;
+    card_brand?: string;
+    billing_email?: string;
+    verified_at: number;
+}
+interface StripeConnectCredentialData {
+    provider: 'stripe_connect';
+    account_id: string;
+    details_submitted: boolean;
+    charges_enabled: boolean;
+    payouts_enabled: boolean;
+    email?: string;
+    verified_at: number;
+}
+interface CredentialLinkProof {
+    chain?: Web3Chain;
+    message?: string;
+    signature?: string;
+    public_key?: string;
+    provider?: string;
+    code?: string;
+    email?: string;
+}
+interface GlobalIdentity {
+    id: string;
+    identity_commitment: string;
+    root_public_key: string;
+    recovery_commitments: string[];
+    created_at: number;
+    updated_at: number;
+}
+interface StackIdentity {
+    id: string;
+    global_identity_id: string;
+    stack_id: string;
+    stack_public_key: string;
+    created_at: number;
+    last_login: number;
+}
+interface Session {
+    id: string;
+    app_identity_id: string;
+    global_identity_commitment: string;
+    app_id: string;
+    credentials: string[];
+    app_pubkey: string;
+    jwt: string;
+    issued_at: number;
+    expires_at: number;
+    issuer: string;
+    signed_by: string[];
+}
+
+export type { AuthMethod, BillingCredentialData, CoderClientConfig, CoderCommandInput, CoderCommandResult, CoderDiffInput, CoderExecuteRequest, CoderExecuteResponse, CoderFileContent, CoderFileInfo, CoderFileWriteInput, CoderFilesResponse, CoderMetrics, CoderProgressEvent, CoderSandbox, CoderSandboxConfig, CoderSandboxCreateInput, CoderSandboxExecInput, CoderSandboxExecResult, CoderSandboxResponse, CoderSearchResult, CoderSession, CoderSessionResponse, CoderSessionStatus, CoderSessionsListResponse, CoderStreamEvent, CoderStreamEventType, CoderThinkingEvent, CoderTool, CoderToolCallEvent, CoderToolParameter, CoderToolResult, CoderToolResultEvent, CoderToolsResponse, CredentialLinkProof, CredentialType, EmailCredentialData, GlobalIdentity, OAuthCredentialData, Session, StackCredential, StackIdentity, StripeConnectCredentialData, Web3Chain, Web3CredentialData };