@superblocksteam/sdk-api 0.0.5 → 0.0.7

package/src/api/definition.test.ts

@@ -5,10 +5,11 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { describe, it, expect, expectTypeOf } from "vitest";
 import { z } from "zod";
+
 import {
   api,
   __setEntryPoint,
-  consumeEntryPoint,
+  getEntryPoint,
   type ExtractApiInput,
   type ExtractApiOutput,
 } from "./definition.js";
@@ -344,27 +345,52 @@ describe("entryPoint mechanism", () => {
     expect(compiled.entryPoint).toBe("server/apis/GetUsers/api.ts");
   });
 
-  it("consumeEntryPoint clears the pending value", () => {
-    __setEntryPoint("server/apis/Temp/api.ts");
-    const first = consumeEntryPoint();
-    const second = consumeEntryPoint();
+  it("entryPoint persists across multiple api() calls from the same file", () => {
+    __setEntryPoint("server/apis/slack/helper.ts");
+    const dashboard = api({
+      name: "SlackDashboard",
+      input: z.object({}),
+      output: z.object({}),
+      async run() {
+        return {};
+      },
+    });
+    const search = api({
+      name: "SlackSearch",
+      input: z.object({}),
+      output: z.object({}),
+      async run() {
+        return {};
+      },
+    });
+    const postMessage = api({
+      name: "SlackPostMessage",
+      input: z.object({}),
+      output: z.object({}),
+      async run() {
+        return {};
+      },
+    });
 
-    expect(first).toBe("server/apis/Temp/api.ts");
-    expect(second).toBeUndefined();
+    expect(dashboard.entryPoint).toBe("server/apis/slack/helper.ts");
+    expect(search.entryPoint).toBe("server/apis/slack/helper.ts");
+    expect(postMessage.entryPoint).toBe("server/apis/slack/helper.ts");
   });
 
-  it("entryPoint is consumed once — second api() call gets undefined", () => {
-    __setEntryPoint("server/apis/First/api.ts");
-    const first = api({
-      name: "First",
+  it("new __setEntryPoint overwrites previous value for a different file", () => {
+    __setEntryPoint("server/apis/slack/helper.ts");
+    const slackApi = api({
+      name: "SlackDashboard",
       input: z.object({}),
       output: z.object({}),
       async run() {
         return {};
       },
     });
-    const second = api({
-      name: "Second",
+
+    __setEntryPoint("server/apis/users/api.ts");
+    const usersApi = api({
+      name: "GetUsers",
       input: z.object({}),
       output: z.object({}),
       async run() {
@@ -372,7 +398,7 @@ describe("entryPoint mechanism", () => {
       },
     });
 
-    expect(first.entryPoint).toBe("server/apis/First/api.ts");
-    expect(second.entryPoint).toBeUndefined();
+    expect(slackApi.entryPoint).toBe("server/apis/slack/helper.ts");
+    expect(usersApi.entryPoint).toBe("server/apis/users/api.ts");
   });
 });

package/src/api/definition.ts

@@ -44,29 +44,36 @@ export type ExtractApiInput<T> =
 export type ExtractApiOutput<T> =
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   T extends CompiledApi<any, infer TOutput> ? TOutput : never;
-import type { ApiConfig, ApiContext, AnyIntegrationRef } from "../types.js";
 import {
   extractIntegrationDeclarations,
   type IntegrationDeclaration,
 } from "../integrations/declarations.js";
+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
-// synchronous, so the prepended __setEntryPoint() always runs before api().
+// onto every api()/streamingApi() call in a module.  ESM top-level execution
+// is synchronous, so the prepended __setEntryPoint() always runs before any
+// api() call in the same file.  The value is intentionally NOT cleared after
+// the first read so that multiple named-exported api() calls in a single file
+// all receive the same entry point.  The next file's __setEntryPoint() call
+// naturally overwrites the value.
 // ---------------------------------------------------------------------------
 
 let __pendingEntryPoint: string | undefined;
 
-/** Called by the Vite plugin to set the entry point for the next api() call. */
+/** Called by the Vite plugin to set the entry point for api() calls in this file. */
 export function __setEntryPoint(entryPoint: string): void {
   __pendingEntryPoint = entryPoint;
 }
 
-export function consumeEntryPoint(): string | undefined {
-  const ep = __pendingEntryPoint;
-  __pendingEntryPoint = undefined;
-  return ep;
+/**
+ * Returns the current pending entry point without clearing it.
+ * This allows multiple api() calls within the same file to share the same
+ * entry point (e.g. named exports from a single module).
+ */
+export function getEntryPoint(): string | undefined {
+  return __pendingEntryPoint;
 }
 
 /**
@@ -170,10 +177,10 @@ export interface CompiledApi<TInput = unknown, TOutput = unknown> {
  *       throw new Error('User not found');
  *     }
  *
- *     await ctx.integrations.notifier.postMessage({
- *       channel: '#user-lookups',
- *       text: `Fetched user ${user.name}`,
- *     });
+ *     await ctx.integrations.notifier.apiRequest(
+ *       { method: 'POST', path: '/chat.postMessage', body: { channel: '#user-lookups', text: `Fetched user ${user.name}` } },
+ *       { response: z.object({ ok: z.boolean() }) }
+ *     );
  *
  *     return { user };
  *   },
@@ -196,7 +203,7 @@ export function api<
   const compiled: CompiledApi<z.infer<TInput>, z.infer<TOutput>> = {
     name: config.name,
     description: config.description,
-    entryPoint: consumeEntryPoint(),
+    entryPoint: getEntryPoint(),
     inputSchema: config.input,
     outputSchema: config.output,
     run: config.run as (

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

@@ -53,7 +53,7 @@ export class QueryValidationError extends Error {
 }
 
 /**
- * Error thrown when Python/JavaScript code execution fails.
+ * Error thrown when code execution fails.
  *
  * Contains context about the code, bindings, and any validation errors
  * that occurred during execution.
@@ -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

@@ -38,10 +38,14 @@
  *       throw new Error('User not found');
  *     }
  *
- *     await ctx.integrations.notifier.postMessage({
- *       channel: '#user-lookups',
- *       text: `Fetched user ${user.name}`,
- *     });
+ *     const notifyResult = await ctx.integrations.notifier.apiRequest(
+ *       { method: 'POST', path: '/chat.postMessage', body: { channel: '#user-lookups', text: `Fetched user ${user.name}` } },
+ *       { response: z.object({ channel: z.string(), ts: z.string() }) }
+ *     );
+ *
+ *     if (!notifyResult.ok) {
+ *       throw new Error(`Slack API error: ${notifyResult.error}`);
+ *     }
  *
  *     return { user };
  *   },
@@ -59,16 +63,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";
@@ -138,20 +133,13 @@ export {
   mongodb,
   dynamodb,
   cosmosdb,
-  couchbase,
   s3,
   gcs,
   googleSheets,
-  kafka,
-  kinesis,
   salesforce,
-  redis,
   superblocksOcr,
-  python,
   restApiIntegration,
   getIntegrationDeclarations,
-  confluent,
-  redpanda,
   lakebase,
   snowflakePostgres,
   smtp,
@@ -208,19 +196,12 @@ export {
   type MongoDBRef,
   type DynamoDBRef,
   type CosmosDBRef,
-  type CouchbaseRef,
   type S3Ref,
   type GCSRef,
   type GoogleSheetsRef,
-  type KafkaRef,
-  type KinesisRef,
   type SalesforceRef,
-  type RedisRef,
   type SuperblocksOCRRef,
-  type PythonRef,
   type RestApiIntegrationRef,
-  type ConfluentRef,
-  type RedpandaRef,
   type LakebaseRef,
   type SnowflakePostgresRef,
   type SmtpRef,
@@ -228,7 +209,11 @@ export {
 
 // Integration client types (for advanced use cases)
 export type { PostgresClient } from "./integrations/postgres/index.js";
-export type { SlackClient } from "./integrations/slack/index.js";
+export type {
+  SlackClient,
+  SlackResponse,
+  SlackErrorResponse,
+} from "./integrations/slack/index.js";
 export type { SnowflakeClient } from "./integrations/snowflake/index.js";
 export type { SnowflakeCortexClient } from "./integrations/snowflakecortex/index.js";
 export type { AirtableClient } from "./integrations/airtable/index.js";
@@ -268,29 +253,15 @@ export type {
   DynamoDBAttributeValue,
 } from "./integrations/dynamodb/index.js";
 export type { CosmosDBClient } from "./integrations/cosmosdb/index.js";
-export type {
-  CouchbaseClient,
-  CouchbaseIdentifier,
-} from "./integrations/couchbase/index.js";
-export type {
-  KinesisClient,
-  KinesisPutParams,
-  KinesisGetParams,
-  KinesisStreamIdentifier,
-  KinesisShardIteratorType,
-} from "./integrations/kinesis/index.js";
 export type {
   SalesforceClient,
   SalesforceCrudAction,
   SalesforceBulkAction,
 } from "./integrations/salesforce/index.js";
-export type { RedisClient } from "./integrations/redis/index.js";
-export type { KafkaClient } from "./integrations/kafka/index.js";
 export type { S3Client } from "./integrations/s3/index.js";
 export type { GCSClient } from "./integrations/gcs/index.js";
 export type { GoogleSheetsClient } from "./integrations/gsheets/index.js";
 export type { SuperblocksOCRClient } from "./integrations/superblocks-ocr/index.js";
-export type { PythonClient } from "./integrations/python/index.js";
 export type { RestApiIntegrationPluginClient } from "./integrations/restapiintegration/index.js";
 export type { LakebaseClient } from "./integrations/lakebase/index.js";
 export type { SnowflakePostgresClient } from "./integrations/snowflakepostgres/index.js";
@@ -298,15 +269,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 +284,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";
 
@@ -341,6 +298,7 @@ export {
   createClient,
   isPluginSupported,
   SUPPORTED_PLUGINS,
+  SUPPORTED_PLUGIN_IDS,
 } from "./integrations/index.js";
 
 export type {
@@ -348,16 +306,17 @@ export type {
   IntegrationClientImpl,
   SupportedPluginId,
   QueryExecutor,
-  StreamingQueryExecutor,
   TraceMetadata,
   CreateClientOptions,
 } from "./integrations/index.js";
 
+// resolveIntegrationDocumentation is intentionally NOT re-exported here.
+// It uses node:fs which is incompatible with browser bundles (Vite dev server).
+// Import directly from "@superblocksteam/sdk-api/dist/integrations/documentation.js" instead.
+
 // SDK-level error types
 export {
   RestApiValidationError,
   QueryValidationError,
   CodeExecutionError,
-  StreamChunkValidationError,
-  StreamError,
 } from "./errors.js";

package/src/integrations/airtable/docs.manifest.json

@@ -0,0 +1,5 @@
+{
+  "pluginId": "airtable",
+  "base": "README.md",
+  "overlays": []
+}

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/docs.manifest.json

@@ -0,0 +1,5 @@
+{
+  "pluginId": "anthropic",
+  "base": "README.md",
+  "overlays": []
+}

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
 }