@superblocksteam/sdk-api 2.0.103 → 2.0.104-next.1

package/dist/runtime/index.js

@@ -4,15 +4,10 @@
  * Provides the execution engine for running compiled APIs,
  * including context creation, validation, and error handling.
  */
-// Unified executor (recommended)
-export { execute, isStreamingApi, } from "./execute.js";
-// Main executor (for non-streaming APIs)
+// Main executor
 export { executeApi, } from "./executor.js";
-// Streaming executor (for streaming APIs)
-export { executeStreamingApi, createStreamingApiGenerator, } from "./streaming-executor.js";
 // Context factories
 export { createApiContext } from "./context.js";
-export { createStreamingApiContext, } from "./streaming-context.js";
 // Error types
 export { SdkError, InputValidationError, OutputValidationError, IntegrationNotFoundError, IntegrationError, ExecutionError, ErrorCode, } from "./errors.js";
 //# sourceMappingURL=index.js.map

package/dist/runtime/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,iCAAiC;AACjC,OAAO,EACL,OAAO,EACP,cAAc,GAGf,MAAM,cAAc,CAAC;AAEtB,yCAAyC;AACzC,OAAO,EACL,UAAU,GAKX,MAAM,eAAe,CAAC;AAEvB,0CAA0C;AAC1C,OAAO,EACL,mBAAmB,EACnB,2BAA2B,GAK5B,MAAM,yBAAyB,CAAC;AAEjC,oBAAoB;AACpB,OAAO,EAAE,gBAAgB,EAA6B,MAAM,cAAc,CAAC;AAC3E,OAAO,EACL,yBAAyB,GAE1B,MAAM,wBAAwB,CAAC;AAEhC,cAAc;AACd,OAAO,EACL,QAAQ,EACR,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,gBAAgB,EAChB,cAAc,EACd,SAAS,GAEV,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,gBAAgB;AAChB,OAAO,EACL,UAAU,GAKX,MAAM,eAAe,CAAC;AAEvB,oBAAoB;AACpB,OAAO,EAAE,gBAAgB,EAA6B,MAAM,cAAc,CAAC;AAE3E,cAAc;AACd,OAAO,EACL,QAAQ,EACR,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,gBAAgB,EAChB,cAAc,EACd,SAAS,GAEV,MAAM,aAAa,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superblocksteam/sdk-api",
-  "version": "2.0.103",
+  "version": "2.0.104-next.1",
   "description": "Superblocks SDK for TypeScript-based API definitions",
   "license": "Superblocks Community Software License",
   "files": [

package/src/api/definition.ts

@@ -52,7 +52,7 @@ import type { ApiConfig, ApiContext, AnyIntegrationRef } from "../types.js";
 
 // ---------------------------------------------------------------------------
 // Entry point setter — used by the Vite plugin to stamp the source file path
-// onto the next api()/streamingApi() call. ESM top-level execution is
+// onto the next api() call. ESM top-level execution is
 // synchronous, so the prepended __setEntryPoint() always runs before api().
 // ---------------------------------------------------------------------------
 

package/src/api/index.ts

@@ -4,7 +4,3 @@
 
 export { api, __setEntryPoint } from "./definition.js";
 export type { CompiledApi } from "./definition.js";
-
-// Streaming API support
-export { streamingApi, isStreamingApi } from "./streaming.js";
-export type { StreamingApiConfig, CompiledStreamingApi } from "./streaming.js";

package/src/errors.ts

@@ -80,51 +80,3 @@ export class CodeExecutionError extends Error {
     Object.setPrototypeOf(this, CodeExecutionError.prototype);
   }
 }
-
-/**
- * Error thrown when a streamed chunk fails validation.
- *
- * Contains information about the chunk index, the raw chunk data,
- * and the Zod validation error details.
- */
-export class StreamChunkValidationError extends Error {
-  constructor(
-    message: string,
-    public readonly details: {
-      /** Index of the chunk that failed validation (0-based) */
-      chunkIndex: number;
-      /** The raw chunk data that failed validation */
-      chunk: unknown;
-      /** The complete Zod error object with all validation information */
-      zodError: z.ZodError;
-    },
-  ) {
-    super(message);
-    this.name = "StreamChunkValidationError";
-    // Ensure proper prototype chain for instanceof checks
-    Object.setPrototypeOf(this, StreamChunkValidationError.prototype);
-  }
-}
-
-/**
- * Error thrown when a streaming API encounters an error mid-stream.
- *
- * This error indicates that the stream was interrupted before completion.
- * Contains context about where in the stream the error occurred.
- */
-export class StreamError extends Error {
-  constructor(
-    message: string,
-    public readonly details?: {
-      /** Number of chunks successfully received before the error */
-      chunksReceived?: number;
-      /** The original error that caused the stream to fail */
-      originalError?: unknown;
-    },
-  ) {
-    super(message);
-    this.name = "StreamError";
-    // Ensure proper prototype chain for instanceof checks
-    Object.setPrototypeOf(this, StreamError.prototype);
-  }
-}

package/src/index.ts

@@ -59,16 +59,7 @@ export { fileRefSchema, readableFileSchema } from "./files.js";
 export type { FileRef, ReadableFile } from "./files.js";
 
 // API definition and registry
-export {
-  api,
-  __setEntryPoint,
-  type CompiledApi,
-  // Streaming API support
-  streamingApi,
-  isStreamingApi,
-  type StreamingApiConfig,
-  type CompiledStreamingApi,
-} from "./api/index.js";
+export { api, __setEntryPoint, type CompiledApi } from "./api/index.js";
 
 // Type extraction utilities
 export type { ExtractApiInput, ExtractApiOutput } from "./api/definition.js";
@@ -298,15 +289,10 @@ export type { SmtpClient, SmtpSendOptions } from "./integrations/smtp/index.js";
 
 // Runtime (for orchestrator use)
 export {
-  // Unified executor (recommended - handles both regular and streaming)
-  execute,
-  // Legacy executors (still available for specific use cases)
+  // Executor
   executeApi,
-  executeStreamingApi,
-  createStreamingApiGenerator,
   // Context factories
   createApiContext,
-  createStreamingApiContext,
   // Error types
   SdkError,
   InputValidationError,
@@ -318,21 +304,12 @@ export {
 } from "./runtime/index.js";
 
 export type {
-  // Unified types (recommended)
-  UnifiedExecuteApiRequest,
-  AnyCompiledApi,
-  // Legacy types (still available)
   ExecuteApiRequest,
   ExecuteApiResponse,
   ExecuteApiSuccessResponse,
   ExecuteApiErrorResponse,
-  ExecuteStreamingApiRequest,
-  StreamingApiCallbacks,
-  StreamingApiError,
-  ExecuteStreamingApiResult,
   // Context types
   CreateContextOptions,
-  CreateStreamingContextOptions,
   ErrorCodeType,
 } from "./runtime/index.js";
 
@@ -348,7 +325,6 @@ export type {
   IntegrationClientImpl,
   SupportedPluginId,
   QueryExecutor,
-  StreamingQueryExecutor,
   TraceMetadata,
   CreateClientOptions,
 } from "./integrations/index.js";
@@ -358,6 +334,4 @@ export {
   RestApiValidationError,
   QueryValidationError,
   CodeExecutionError,
-  StreamChunkValidationError,
-  StreamError,
 } from "./errors.js";

package/src/integrations/anthropic/README.md

@@ -4,10 +4,9 @@ Interact with Anthropic's Claude API for powerful AI conversations and text gene
 
 ## Methods
 
-| Method                                         | Description                                           |
-| ---------------------------------------------- | ----------------------------------------------------- |
-| `apiRequest(options, schema, metadata?)`       | Make any Anthropic API request with schema validation |
-| `streamApiRequest(options, schema, metadata?)` | Stream responses with real-time chunk validation      |
+| Method                                   | Description                                           |
+| ---------------------------------------- | ----------------------------------------------------- |
+| `apiRequest(options, schema, metadata?)` | Make any Anthropic API request with schema validation |
 
 ## Usage
 
@@ -242,89 +241,6 @@ const result = await ctx.integrations.ai.apiRequest(
 );
 ```
 
-### Streaming Messages
-
-For real-time token streaming, use `streamApiRequest()` with `stream: true`:
-
-```typescript
-import { streamingApi, z, anthropic } from "@superblocksteam/sdk-api";
-
-// Integration ID from the integrations panel
-const PROD_ANTHROPIC = "a1b2c3d4-5678-90ab-cdef-444444444444";
-
-// Schema for Anthropic's streaming SSE events
-const AnthropicStreamEventSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("content_block_delta"),
-    index: z.number(),
-    delta: z.object({
-      type: z.literal("text_delta"),
-      text: z.string(),
-    }),
-  }),
-  z.object({ type: z.literal("message_start"), message: z.any() }),
-  z.object({
-    type: z.literal("content_block_start"),
-    index: z.number(),
-    content_block: z.any(),
-  }),
-  z.object({ type: z.literal("content_block_stop"), index: z.number() }),
-  z.object({
-    type: z.literal("message_delta"),
-    delta: z.any(),
-    usage: z.any(),
-  }),
-  z.object({ type: z.literal("message_stop") }),
-  z.object({ type: z.literal("ping") }),
-]);
-
-export default streamingApi({
-  integrations: {
-    ai: anthropic(PROD_ANTHROPIC),
-  },
-
-  input: z.object({ prompt: z.string() }),
-  chunk: z.object({ type: z.literal("text"), text: z.string() }),
-
-  async *run(ctx, { prompt }) {
-    const stream = ctx.integrations.ai.streamApiRequest(
-      {
-        method: "POST",
-        path: "/v1/messages",
-        body: {
-          model: "claude-3-5-sonnet-20241022",
-          max_tokens: 1024,
-          stream: true, // Enable streaming
-          messages: [{ role: "user", content: prompt }],
-        },
-      },
-      { chunk: AnthropicStreamEventSchema },
-    );
-
-    // Yield text chunks as they arrive
-    for await (const event of stream) {
-      if (event.type === "content_block_delta") {
-        yield { type: "text" as const, text: event.delta.text };
-      }
-    }
-  },
-});
-```
-
-#### Streaming Event Types
-
-Claude's streaming API sends these event types:
-
-| Event Type            | Description                                 |
-| --------------------- | ------------------------------------------- |
-| `message_start`       | Initial message metadata (model, id, usage) |
-| `content_block_start` | Start of a content block (text, tool_use)   |
-| `content_block_delta` | Incremental text or tool input              |
-| `content_block_stop`  | End of a content block                      |
-| `message_delta`       | Final message metadata (stop_reason, usage) |
-| `message_stop`        | Stream complete                             |
-| `ping`                | Keep-alive ping                             |
-
 ## Trace Metadata
 
 All methods accept an optional `metadata` parameter as the last argument for diagnostics labeling. See the [root SDK README](../../../README.md#trace-metadata) for details.
@@ -333,7 +249,7 @@ All methods accept an optional `metadata` parameter as the last argument for dia
 
 ### No Specialized Methods
 
-The Anthropic client only provides `apiRequest()`:
+The Anthropic client only provides `apiRequest()`. There are no other specialized methods:
 
 ```typescript
 // WRONG - These methods do not exist
@@ -474,7 +390,7 @@ const result = await ctx.integrations.ai.apiRequest(
 ## Error Handling
 
 ```typescript
-import { RestApiValidationError, StreamChunkValidationError } from "@superblocksteam/sdk-api";
+import { RestApiValidationError } from "@superblocksteam/sdk-api";
 
 try {
   const result = await ctx.integrations.ai.apiRequest(
@@ -487,18 +403,6 @@ try {
     console.error("Actual response:", error.details.data);
   }
 }
-
-// For streaming requests
-try {
-  for await (const chunk of stream) {
-    // Process chunk
-  }
-} catch (error) {
-  if (error instanceof StreamChunkValidationError) {
-    console.error("Chunk validation failed at index:", error.details.chunkIndex);
-    console.error("Raw chunk:", error.details.chunk);
-  }
-}
 ```
 
 ## API Reference

package/src/integrations/anthropic/types.ts

@@ -3,16 +3,12 @@
  */
 
 import type { BaseIntegrationClient } from "../../types.js";
-import type {
-  SupportsApiRequest,
-  SupportsStreamingApiRequest,
-} from "../base/index.js";
+import type { SupportsApiRequest } from "../base/index.js";
 
 /**
  * Anthropic client for Claude AI model interactions.
  *
- * Provides the generic apiRequest() method for any Anthropic API endpoint,
- * and streamApiRequest() for streaming responses.
+ * Provides the generic apiRequest() method for any Anthropic API endpoint.
  * Use this to interact with Anthropic's messages API and other endpoints.
  *
  * @example
@@ -58,31 +54,9 @@ import type {
  *   }
  * );
  *
- * // Or use streaming for real-time responses
- * const stream = anthropic.streamApiRequest(
- *   {
- *     method: 'POST',
- *     path: '/v1/messages',
- *     body: {
- *       model: 'claude-3-5-sonnet-20241022',
- *       max_tokens: 1024,
- *       stream: true,
- *       messages: [{ role: 'user', content: 'Hello!' }],
- *     },
- *   },
- *   { chunk: StreamEventSchema }
- * );
- *
- * for await (const event of stream) {
- *   // Handle streaming events
- * }
  * ```
  */
 export interface AnthropicClient
-  extends
-    BaseIntegrationClient,
-    SupportsApiRequest,
-    SupportsStreamingApiRequest {
+  extends BaseIntegrationClient, SupportsApiRequest {
   // apiRequest() method inherited from SupportsApiRequest
-  // streamApiRequest() method inherited from SupportsStreamingApiRequest
 }

package/src/integrations/athena/README.md

@@ -41,7 +41,7 @@ export default api({
     const logs = await ctx.integrations.athena.query(
       `SELECT timestamp, level, message, request_id
        FROM logs
-       WHERE level = $1
+       WHERE level = ?
        LIMIT 100`,
       LogSchema,
       [level],
@@ -65,8 +65,8 @@ const EventSchema = z.object({
 const events = await ctx.integrations.athena.query(
   `SELECT event_id, event_type, user_id, created_at
    FROM events
-   WHERE date_partition = $1
-     AND event_type = $2`,
+   WHERE date_partition = ?
+     AND event_type = ?`,
   EventSchema,
   ["2024-01-15", "purchase"],
 );
@@ -138,7 +138,7 @@ Always use partition filters when possible to reduce data scanned:
 ```typescript
 // GOOD - Uses partition filter
 const logs = await ctx.integrations.athena.query(
-  "SELECT * FROM logs WHERE date_partition = $1",
+  "SELECT * FROM logs WHERE date_partition = ?",
   LogSchema,
   ["2024-01-15"],
 );

package/src/integrations/athena/types.ts

@@ -25,7 +25,7 @@ import type { TraceMetadata } from "../registry.js";
  * });
  *
  * const logs = await athena.query(
- *   'SELECT * FROM logs WHERE level = $1',
+ *   'SELECT * FROM logs WHERE level = ?',
  *   LogSchema,
  *   ['ERROR']
  * );
@@ -35,7 +35,7 @@ export interface AthenaClient extends BaseIntegrationClient {
   /**
    * Execute a SQL query and validate results against a Zod schema.
    *
-   * @param sql - SQL query string (use $1, $2, etc. for parameters)
+   * @param sql - SQL query string (use ? placeholders for parameters)
    * @param schema - Zod schema to validate the query results
    * @param params - Optional query parameters
    * @returns Promise resolving to validated query results

package/src/integrations/base/index.ts

@@ -9,6 +9,4 @@ export type {
   ApiRequestOptions,
   ApiRequestSchema,
   SupportsApiRequest,
-  StreamApiRequestSchema,
-  SupportsStreamingApiRequest,
 } from "./types.js";

package/src/integrations/base/rest-api-integration-client.ts

@@ -10,22 +10,13 @@ import type { z } from "zod";
 import type { Property } from "@superblocksteam/types/dist/src/common/v1/plugin_pb";
 import type { Plugin as RestApiIntegrationPlugin } from "@superblocksteam/types/dist/src/plugins/restapiintegration/v1/plugin_pb";
 
-import {
-  RestApiValidationError,
-  StreamChunkValidationError,
-} from "../../errors.js";
-import type {
-  QueryExecutor,
-  StreamingQueryExecutor,
-  TraceMetadata,
-} from "../registry.js";
+import { RestApiValidationError } from "../../errors.js";
+import type { QueryExecutor, TraceMetadata } from "../registry.js";
 import type { IntegrationConfig, IntegrationClientImpl } from "../types.js";
 import type {
   ApiRequestOptions,
   ApiRequestSchema,
   SupportsApiRequest,
-  StreamApiRequestSchema,
-  SupportsStreamingApiRequest,
 } from "./types.js";
 
 export type RestApiRequest = PartialMessage<RestApiIntegrationPlugin>;
@@ -35,31 +26,21 @@ export type RestApiRequest = PartialMessage<RestApiIntegrationPlugin>;
  *
  * All OpenAPI-based integration clients extend this class to inherit
  * the generic apiRequest() method with runtime schema validation.
- * Also supports streaming API requests when a streaming executor is provided.
  */
 export abstract class RestApiIntegrationClient
-  implements
-    IntegrationClientImpl,
-    SupportsApiRequest,
-    SupportsStreamingApiRequest
+  implements IntegrationClientImpl, SupportsApiRequest
 {
   readonly name: string;
   readonly pluginId: string;
   readonly config: IntegrationConfig;
 
   protected readonly executeQuery: QueryExecutor;
-  protected readonly executeStreamingQuery?: StreamingQueryExecutor;
 
-  constructor(
-    config: IntegrationConfig,
-    executeQuery: QueryExecutor,
-    executeStreamingQuery?: StreamingQueryExecutor,
-  ) {
+  constructor(config: IntegrationConfig, executeQuery: QueryExecutor) {
     this.name = config.name;
     this.pluginId = config.pluginId;
     this.config = config;
     this.executeQuery = executeQuery;
-    this.executeStreamingQuery = executeStreamingQuery;
   }
 
   /**
@@ -148,134 +129,4 @@ export abstract class RestApiIntegrationClient
 
     return responseParseResult.data;
   }
-
-  /**
-   * Execute a streaming API request with type-safe chunk validation.
-   *
-   * Returns an AsyncIterable that yields validated chunks as they arrive.
-   * Each chunk is validated against the provided schema before being yielded.
-   *
-   * @param options - Request configuration including method, path, params, and body
-   * @param schema - Zod schemas for request body and chunk validation
-   * @param metadata - Optional trace metadata for observability (label, description)
-   * @returns AsyncIterable yielding validated chunks
-   *
-   * @example
-   * ```typescript
-   * const ChunkSchema = z.object({
-   *   id: z.string(),
-   *   choices: z.array(z.object({
-   *     delta: z.object({
-   *       content: z.string().optional(),
-   *     }),
-   *   })),
-   * });
-   *
-   * const stream = client.streamApiRequest(
-   *   {
-   *     method: 'POST',
-   *     path: '/v1/chat/completions',
-   *     body: {
-   *       model: 'gpt-4',
-   *       stream: true,
-   *       messages: [{ role: 'user', content: 'Hello!' }],
-   *     },
-   *   },
-   *   { chunk: ChunkSchema },
-   *   { label: 'openai.chatCompletions', description: 'Stream chat completion' }
-   * );
-   *
-   * for await (const chunk of stream) {
-   *   console.log(chunk.choices[0]?.delta?.content);
-   * }
-   * ```
-   */
-  async *streamApiRequest<TBody, TChunk>(
-    options: ApiRequestOptions<TBody>,
-    schema: StreamApiRequestSchema<TBody, TChunk>,
-    metadata?: TraceMetadata,
-  ): AsyncIterable<TChunk> {
-    // Validate that streaming is supported
-    if (!this.executeStreamingQuery) {
-      throw new Error(
-        `Streaming is not supported for integration "${this.name}". ` +
-          "The orchestrator must provide a streaming query executor.",
-      );
-    }
-
-    // Validate request body against schema if both are present.
-    // Body schema is optional — if not provided, the body is sent unvalidated.
-    if (options.body !== undefined && schema?.body) {
-      const bodyParseResult = schema.body.safeParse(options.body);
-      if (!bodyParseResult.success) {
-        throw new RestApiValidationError(
-          `Request body validation failed: ${bodyParseResult.error.message}`,
-          {
-            zodError: bodyParseResult.error,
-            data: options.body,
-          },
-        );
-      }
-    }
-
-    // Convert headers to Property array
-    const headers: PartialMessage<Property>[] = [];
-    if (options.headers) {
-      for (const [key, value] of Object.entries(options.headers)) {
-        headers.push(this.createParam(key, value));
-      }
-    }
-
-    // Convert query params to Property array
-    const params: PartialMessage<Property>[] = [];
-    if (options.params) {
-      for (const [key, value] of Object.entries(options.params)) {
-        params.push(this.createParam(key, value));
-      }
-    }
-
-    // Build the request using raw HTTP mode with streaming response
-    // Note: responseType must be "raw" for streaming - the orchestrator's
-    // Stream block expects SSE responses and only works with "raw" type.
-    const request: RestApiRequest = {
-      openApiAction: "genericHttpRequest",
-      httpMethod: options.method.toUpperCase(),
-      urlPath: options.path,
-      headers,
-      params,
-      responseType: "raw",
-    };
-
-    // Add body if provided
-    if (options.body !== undefined) {
-      request.body = JSON.stringify(options.body);
-      request.bodyType = "jsonBody";
-    }
-
-    // Execute the streaming request
-    const stream = this.executeStreamingQuery(
-      request as Record<string, unknown>,
-      metadata,
-    );
-
-    // Validate and yield each chunk
-    let chunkIndex = 0;
-    for await (const rawChunk of stream) {
-      const parseResult = schema.chunk.safeParse(rawChunk);
-
-      if (!parseResult.success) {
-        throw new StreamChunkValidationError(
-          `Chunk validation failed at index ${chunkIndex}: ${parseResult.error.message}`,
-          {
-            chunkIndex,
-            chunk: rawChunk,
-            zodError: parseResult.error,
-          },
-        );
-      }
-
-      yield parseResult.data;
-      chunkIndex++;
-    }
-  }
 }