@tetral-ai/sdk 0.110.0-alpha.1

package/src/helpers/beta/zod.ts

@@ -0,0 +1,81 @@
+import { transformJSONSchema } from '../..//lib/transform-json-schema';
+import * as z from 'zod/v4';
+import { AnthropicError } from '../../core/error';
+import { AutoParseableBetaOutputFormat } from '../../lib/beta-parser';
+import { BetaRunnableTool, BetaToolRunContext, Promisable } from '../../lib/tools/BetaRunnableTool';
+import { BetaToolResultContentBlockParam } from '../../resources/beta';
+/**
+ * Creates a JSON schema output format object from the given Zod schema.
+ *
+ * If this is passed to the `.parse()` method then the response message will contain a
+ * `.parsed_output` property that is the result of parsing the content with the given Zod object.
+ *
+ * This can be passed directly to the `.create()` method but will not
+ * result in any automatic parsing, you'll have to parse the response yourself.
+ */
+export function betaZodOutputFormat<ZodInput extends z.ZodType>(
+  zodObject: ZodInput,
+): AutoParseableBetaOutputFormat<z.infer<ZodInput>> {
+  let jsonSchema = z.toJSONSchema(zodObject, { reused: 'ref' });
+
+  jsonSchema = transformJSONSchema(jsonSchema);
+
+  return {
+    type: 'json_schema',
+    schema: {
+      ...jsonSchema,
+    },
+    parse: (content) => {
+      const output = zodObject.safeParse(JSON.parse(content));
+
+      if (!output.success) {
+        throw new AnthropicError(
+          `Failed to parse structured output: ${output.error.message} cause: ${output.error.issues}`,
+        );
+      }
+
+      return output.data;
+    },
+  };
+}
+
+/**
+ * Creates a tool using the provided Zod schema that can be passed
+ * into the `.toolRunner()` method. The Zod schema will automatically be
+ * converted into JSON Schema when passed to the API. The provided function's
+ * input arguments will also be validated against the provided schema.
+ */
+export function betaZodTool<InputSchema extends z.ZodType>(options: {
+  name: string;
+  inputSchema: InputSchema;
+  description: string;
+  run: (
+    args: z.infer<InputSchema>,
+    context?: BetaToolRunContext,
+  ) => Promisable<string | Array<BetaToolResultContentBlockParam>>;
+  /**
+   * Optional cleanup hook for tools that hold process-level resources (e.g. a
+   * persistent shell). `client.beta.sessions.events.toolRunner` calls it once
+   * when iteration ends.
+   */
+  close?: () => void | Promise<void>;
+}): BetaRunnableTool<z.infer<InputSchema>> {
+  const jsonSchema = z.toJSONSchema(options.inputSchema, { reused: 'ref' });
+
+  if (jsonSchema.type !== 'object') {
+    throw new Error(`Zod schema for tool "${options.name}" must be an object, but got ${jsonSchema.type}`);
+  }
+
+  // TypeScript doesn't narrow the type after the runtime check, so we need to assert it
+  const objectSchema = jsonSchema as typeof jsonSchema & { type: 'object' };
+
+  return {
+    type: 'custom',
+    name: options.name,
+    input_schema: objectSchema,
+    description: options.description,
+    run: options.run,
+    parse: (args: unknown) => options.inputSchema.parse(args) as z.infer<InputSchema>,
+    ...(options.close ? { close: options.close } : {}),
+  };
+}

package/src/helpers/index.ts

@@ -0,0 +1,2 @@
+export { jsonSchemaOutputFormat } from './json-schema';
+export { zodOutputFormat } from './zod';

package/src/helpers/json-schema.ts

@@ -0,0 +1,48 @@
+import { FromSchema, JSONSchema } from 'json-schema-to-ts';
+import { AutoParseableOutputFormat } from '../lib/parser';
+import { AnthropicError } from '../core/error';
+import { transformJSONSchema } from '../lib/transform-json-schema';
+
+type NoInfer<T> = T extends infer R ? R : never;
+
+/**
+ * Creates a JSON schema output format object from the given JSON schema.
+ * If this is passed to the `.parse()` method then the response message will contain a
+ * `.parsed_output` property that is the result of parsing the content with the given JSON schema.
+ *
+ * Note: When `transform` is enabled (the default), the schema is deep-cloned before transformation,
+ * so the original schema object is not modified.
+ */
+export function jsonSchemaOutputFormat<
+  const Schema extends Exclude<JSONSchema, boolean> & { type: 'object' },
+>(
+  jsonSchema: Schema,
+  options?: {
+    transform?: boolean;
+  },
+): AutoParseableOutputFormat<NoInfer<FromSchema<Schema>>> {
+  if (jsonSchema.type !== 'object') {
+    throw new Error(`JSON schema must be an object, but got ${jsonSchema.type}`);
+  }
+
+  const transform = options?.transform ?? true;
+  if (transform) {
+    jsonSchema = transformJSONSchema(jsonSchema) as Schema;
+  }
+
+  return {
+    type: 'json_schema',
+    schema: {
+      ...jsonSchema,
+    },
+    parse: (content) => {
+      try {
+        return JSON.parse(content);
+      } catch (error) {
+        throw new AnthropicError(
+          `Failed to parse structured output: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    },
+  };
+}

package/src/helpers/zod.ts

@@ -0,0 +1,57 @@
+import { transformJSONSchema } from '../lib/transform-json-schema';
+import * as z from 'zod/v4';
+import { AnthropicError } from '../core/error';
+import { AutoParseableOutputFormat } from '../lib/parser';
+
+/**
+ * Creates a JSON schema output format object from the given Zod schema.
+ *
+ * If this is passed to the `.parse()` method then the response message will contain a
+ * `.parsed_output` property that is the result of parsing the content with the given Zod object.
+ *
+ * This can be passed directly to the `.create()` method but will not
+ * result in any automatic parsing, you'll have to parse the response yourself.
+ */
+export function zodOutputFormat<ZodInput extends z.ZodType>(
+  zodObject: ZodInput,
+): AutoParseableOutputFormat<z.infer<ZodInput>> {
+  let jsonSchema = z.toJSONSchema(zodObject, { reused: 'ref' });
+
+  jsonSchema = transformJSONSchema(jsonSchema);
+
+  return {
+    type: 'json_schema',
+    schema: {
+      ...jsonSchema,
+    },
+    parse: (content) => {
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(content);
+      } catch (error) {
+        throw new AnthropicError(
+          `Failed to parse structured output as JSON: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+
+      const output = zodObject.safeParse(parsed);
+
+      if (!output.success) {
+        const formattedIssues = output.error.issues
+          .slice(0, 5)
+          .map((issue) => `  - ${issue.path.join('.')}: ${issue.message}`)
+          .join('\n');
+        const issueCount = output.error.issues.length;
+        const suffix = issueCount > 5 ? `\n  ... and ${issueCount - 5} more issue(s)` : '';
+
+        throw new AnthropicError(
+          `Failed to parse structured output: ${output.error.message}\nValidation issues:\n${formattedIssues}${suffix}`,
+        );
+      }
+
+      return output.data;
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,47 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Anthropic as default } from './client';
+
+export { type Uploadable, toFile } from './core/uploads';
+export { APIPromise } from './core/api-promise';
+export { type Middleware, type MiddlewareContext, type MiddlewareNext } from './core/middleware';
+export {
+  betaRefusalFallbackMiddleware,
+  BetaFallbackState,
+  type BetaRefusalFallbackError,
+  type BetaRefusalFallbackOptions,
+} from './lib/middleware';
+export {
+  BaseAnthropic,
+  Anthropic,
+  Anthropic as Tetral,
+  type APIRequest,
+  type ClientOptions,
+  HUMAN_PROMPT,
+  AI_PROMPT,
+} from './client';
+export { PagePromise } from './core/pagination';
+export {
+  AnthropicError,
+  APIError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  APIUserAbortError,
+  RetryableError,
+  NotFoundError,
+  ConflictError,
+  RateLimitError,
+  BadRequestError,
+  AuthenticationError,
+  InternalServerError,
+  PermissionDeniedError,
+  UnprocessableEntityError,
+} from './core/error';
+
+export type {
+  AutoParseableOutputFormat,
+  ParsedMessage,
+  ParsedContentBlock,
+  ParseableMessageCreateParams,
+  ExtractParsedContentFromParams,
+} from './lib/parser';

package/src/internal/README.md

@@ -0,0 +1,3 @@
+# `internal`
+
+The modules in this directory are not importable outside this package and will change between releases.

package/src/internal/builtin-types.ts

@@ -0,0 +1,93 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+/**
+ * An alias to the builtin `RequestInit` type so we can
+ * easily alias it in import statements if there are name clashes.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit
+ */
+type _RequestInit = RequestInit;
+
+/**
+ * An alias to the builtin `Response` type so we can
+ * easily alias it in import statements if there are name clashes.
+ *
+ * https://developer.mozilla.org/docs/Web/API/Response
+ */
+type _Response = Response;
+
+/**
+ * The type for the first argument to `fetch`.
+ *
+ * https://developer.mozilla.org/docs/Web/API/Window/fetch#resource
+ */
+type _RequestInfo = Request | URL | string;
+
+/**
+ * The type for constructing `RequestInit` Headers.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit#setting_headers
+ */
+type _HeadersInit = RequestInit['headers'];
+
+/**
+ * The type for constructing `RequestInit` body.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit#body
+ */
+type _BodyInit = RequestInit['body'];
+
+/**
+ * An alias to the builtin `Array<T>` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Array<T> = Array<T>;
+
+/**
+ * An alias to the builtin `Record<K, T>` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Record<K extends keyof any, T> = Record<K, T>;
+
+export type {
+  _Array as Array,
+  _BodyInit as BodyInit,
+  _HeadersInit as HeadersInit,
+  _Record as Record,
+  _RequestInfo as RequestInfo,
+  _RequestInit as RequestInit,
+  _Response as Response,
+};
+
+/**
+ * A copy of the builtin `EndingType` type as it isn't fully supported in certain
+ * environments and attempting to reference the global version will error.
+ *
+ * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L27941
+ */
+type EndingType = 'native' | 'transparent';
+
+/**
+ * A copy of the builtin `BlobPropertyBag` type as it isn't fully supported in certain
+ * environments and attempting to reference the global version will error.
+ *
+ * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L154
+ * https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob#options
+ */
+export interface BlobPropertyBag {
+  endings?: EndingType;
+  type?: string;
+}
+
+/**
+ * A copy of the builtin `FilePropertyBag` type as it isn't fully supported in certain
+ * environments and attempting to reference the global version will error.
+ *
+ * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L503
+ * https://developer.mozilla.org/en-US/docs/Web/API/File/File#options
+ */
+export interface FilePropertyBag extends BlobPropertyBag {
+  lastModified?: number;
+}

package/src/internal/constants.ts

@@ -0,0 +1,15 @@
+// File containing shared constants
+
+/**
+ * Model-specific timeout constraints for non-streaming requests
+ */
+export const MODEL_NONSTREAMING_TOKENS: Record<string, number> = {
+  'claude-opus-4-20250514': 8192,
+  'claude-opus-4-0': 8192,
+  'claude-4-opus-20250514': 8192,
+  'anthropic.claude-opus-4-20250514-v1:0': 8192,
+  'claude-opus-4@20250514': 8192,
+  'claude-opus-4-1-20250805': 8192,
+  'anthropic.claude-opus-4-1-20250805-v1:0': 8192,
+  'claude-opus-4-1@20250805': 8192,
+};

package/src/internal/decoders/jsonl.ts

@@ -0,0 +1,48 @@
+import { AnthropicError } from '../../core/error';
+import { ReadableStreamToAsyncIterable } from '../shims';
+import { LineDecoder, type Bytes } from './line';
+
+export class JSONLDecoder<T> {
+  controller: AbortController;
+
+  constructor(
+    private iterator: AsyncIterableIterator<Bytes>,
+    controller: AbortController,
+  ) {
+    this.controller = controller;
+  }
+
+  private async *decoder(): AsyncIterator<T, any, undefined> {
+    const lineDecoder = new LineDecoder();
+    for await (const chunk of this.iterator) {
+      for (const line of lineDecoder.decode(chunk)) {
+        yield JSON.parse(line) as T;
+      }
+    }
+
+    for (const line of lineDecoder.flush()) {
+      yield JSON.parse(line) as T;
+    }
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return this.decoder();
+  }
+
+  static fromResponse<T>(response: Response, controller: AbortController): JSONLDecoder<T> {
+    if (!response.body) {
+      controller.abort();
+      if (
+        typeof (globalThis as any).navigator !== 'undefined' &&
+        (globalThis as any).navigator.product === 'ReactNative'
+      ) {
+        throw new AnthropicError(
+          `The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`,
+        );
+      }
+      throw new AnthropicError(`Attempted to iterate over a response with no body`);
+    }
+
+    return new JSONLDecoder(ReadableStreamToAsyncIterable<Bytes>(response.body), controller);
+  }
+}

package/src/internal/decoders/line.ts

@@ -0,0 +1,135 @@
+import { concatBytes, decodeUTF8, encodeUTF8 } from '../utils/bytes';
+
+export type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
+
+/**
+ * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
+ * reading lines from text.
+ *
+ * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
+ */
+export class LineDecoder {
+  // prettier-ignore
+  static NEWLINE_CHARS = new Set(['\n', '\r']);
+  static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
+
+  #buffer: Uint8Array;
+  #carriageReturnIndex: number | null;
+
+  constructor() {
+    this.#buffer = new Uint8Array();
+    this.#carriageReturnIndex = null;
+  }
+
+  decode(chunk: Bytes): string[] {
+    if (chunk == null) {
+      return [];
+    }
+
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
+      : chunk;
+
+    this.#buffer = concatBytes([this.#buffer, binaryChunk]);
+
+    const lines: string[] = [];
+    let patternIndex;
+    while ((patternIndex = findNewlineIndex(this.#buffer, this.#carriageReturnIndex)) != null) {
+      if (patternIndex.carriage && this.#carriageReturnIndex == null) {
+        // skip until we either get a corresponding `\n`, a new `\r` or nothing
+        this.#carriageReturnIndex = patternIndex.index;
+        continue;
+      }
+
+      // we got double \r or \rtext\n
+      if (
+        this.#carriageReturnIndex != null &&
+        (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage)
+      ) {
+        lines.push(decodeUTF8(this.#buffer.subarray(0, this.#carriageReturnIndex - 1)));
+        this.#buffer = this.#buffer.subarray(this.#carriageReturnIndex);
+        this.#carriageReturnIndex = null;
+        continue;
+      }
+
+      const endIndex =
+        this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
+
+      const line = decodeUTF8(this.#buffer.subarray(0, endIndex));
+      lines.push(line);
+
+      this.#buffer = this.#buffer.subarray(patternIndex.index);
+      this.#carriageReturnIndex = null;
+    }
+
+    return lines;
+  }
+
+  flush(): string[] {
+    if (!this.#buffer.length) {
+      return [];
+    }
+    return this.decode('\n');
+  }
+}
+
+/**
+ * This function searches the buffer for the end patterns, (\r or \n)
+ * and returns an object with the index preceding the matched newline and the
+ * index after the newline char. `null` is returned if no new line is found.
+ *
+ * ```ts
+ * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 }
+ * ```
+ */
+function findNewlineIndex(
+  buffer: Uint8Array,
+  startIndex: number | null,
+): { preceding: number; index: number; carriage: boolean } | null {
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = startIndex ?? 0; i < buffer.length; i++) {
+    if (buffer[i] === newline) {
+      return { preceding: i, index: i + 1, carriage: false };
+    }
+
+    if (buffer[i] === carriage) {
+      return { preceding: i, index: i + 1, carriage: true };
+    }
+  }
+
+  return null;
+}
+
+export function findDoubleNewlineIndex(buffer: Uint8Array): number {
+  // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
+  // and returns the index right after the first occurrence of any pattern,
+  // or -1 if none of the patterns are found.
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = 0; i < buffer.length - 1; i++) {
+    if (buffer[i] === newline && buffer[i + 1] === newline) {
+      // \n\n
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+      // \r\r
+      return i + 2;
+    }
+    if (
+      buffer[i] === carriage &&
+      buffer[i + 1] === newline &&
+      i + 3 < buffer.length &&
+      buffer[i + 2] === carriage &&
+      buffer[i + 3] === newline
+    ) {
+      // \r\n\r\n
+      return i + 4;
+    }
+  }
+
+  return -1;
+}