@5ss/ai-tools 2.11.1

package/dist/modules/artifacts/index.d.ts

@@ -0,0 +1,337 @@
+import { _ as ArtifactRef, a as ModuleDefinition, o as ToolContext, s as ToolDefinition, v as artifactRefSchema, y as findArtifactRefs } from "../../types-Ccb0DXY9.js";
+import "../../index-CZX5OeOF.js";
+import { s as HttpServiceOptions } from "../../http-service-T7E5UjP8.js";
+import { z } from "zod";
+//#region src/modules/artifacts/contracts.d.ts
+declare const MAX_ARTIFACT_READ_BYTES: number;
+declare const MAX_ARTIFACT_CREATE_BYTES: number;
+declare const MAX_ARTIFACT_INLINE_CHARS: number;
+declare const artifactsCreateInputSchema: z.ZodObject<{
+  key: z.ZodString;
+  body: z.ZodString;
+  encoding: z.ZodEnum<{
+    base64: "base64";
+    utf8: "utf8";
+  }>;
+  media_type: z.ZodOptional<z.ZodString>;
+  filename: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const artifactsCreateOutputSchema: z.ZodObject<{
+  artifact: z.ZodObject<{
+    store: z.ZodEnum<{
+      host: "host";
+      object: "object";
+    }>;
+    key: z.ZodString;
+    media_type: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    byte_length: z.ZodOptional<z.ZodInt>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const artifactsReadRangeInputSchema: z.ZodObject<{
+  source: z.ZodObject<{
+    store: z.ZodEnum<{
+      host: "host";
+      object: "object";
+    }>;
+    key: z.ZodString;
+    media_type: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    byte_length: z.ZodOptional<z.ZodInt>;
+  }, z.core.$strip>;
+  start_byte: z.ZodInt;
+  end_byte: z.ZodInt;
+}, z.core.$strip>;
+declare const artifactsReadRangeOutputSchema: z.ZodObject<{
+  source: z.ZodObject<{
+    store: z.ZodEnum<{
+      host: "host";
+      object: "object";
+    }>;
+    key: z.ZodString;
+    media_type: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    byte_length: z.ZodOptional<z.ZodInt>;
+  }, z.core.$strip>;
+  body_base64: z.ZodString;
+  start_byte: z.ZodInt;
+  end_byte: z.ZodInt;
+  total_bytes: z.ZodOptional<z.ZodInt>;
+  media_type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const artifactsReadLinesInputSchema: z.ZodObject<{
+  source: z.ZodObject<{
+    store: z.ZodEnum<{
+      host: "host";
+      object: "object";
+    }>;
+    key: z.ZodString;
+    media_type: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    byte_length: z.ZodOptional<z.ZodInt>;
+  }, z.core.$strip>;
+  start_line: z.ZodInt;
+  end_line: z.ZodInt;
+}, z.core.$strip>;
+declare const artifactsReadLinesOutputSchema: z.ZodObject<{
+  source: z.ZodObject<{
+    store: z.ZodEnum<{
+      host: "host";
+      object: "object";
+    }>;
+    key: z.ZodString;
+    media_type: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    byte_length: z.ZodOptional<z.ZodInt>;
+  }, z.core.$strip>;
+  text: z.ZodString;
+  start_line: z.ZodInt;
+  end_line: z.ZodInt;
+  total_lines: z.ZodInt;
+}, z.core.$strip>;
+declare const artifactResolveInputSchema: z.ZodObject<{
+  source: z.ZodObject<{
+    store: z.ZodEnum<{
+      host: "host";
+      object: "object";
+    }>;
+    key: z.ZodString;
+    media_type: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    byte_length: z.ZodOptional<z.ZodInt>;
+  }, z.core.$strip>;
+  max_bytes: z.ZodInt;
+}, z.core.$strip>;
+declare const resolvedArtifactSchema: z.ZodObject<{
+  artifact: z.ZodObject<{
+    store: z.ZodEnum<{
+      host: "host";
+      object: "object";
+    }>;
+    key: z.ZodString;
+    media_type: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    byte_length: z.ZodOptional<z.ZodInt>;
+  }, z.core.$strip>;
+  bytes: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+}, z.core.$strip>;
+type ArtifactsCreateInput = z.infer<typeof artifactsCreateInputSchema>;
+type ArtifactsCreateOutput = z.infer<typeof artifactsCreateOutputSchema>;
+type ArtifactsReadRangeInput = z.infer<typeof artifactsReadRangeInputSchema>;
+type ArtifactsReadRangeOutput = z.infer<typeof artifactsReadRangeOutputSchema>;
+type ArtifactsReadLinesInput = z.infer<typeof artifactsReadLinesInputSchema>;
+type ArtifactsReadLinesOutput = z.infer<typeof artifactsReadLinesOutputSchema>;
+type ArtifactResolveInput = z.infer<typeof artifactResolveInputSchema>;
+type ResolvedArtifact = z.infer<typeof resolvedArtifactSchema>;
+type ArtifactsOps = {
+  create(input: ArtifactsCreateInput): Promise<ArtifactsCreateOutput>;
+  readRange(input: ArtifactsReadRangeInput): Promise<ArtifactsReadRangeOutput>;
+  readLines(input: ArtifactsReadLinesInput): Promise<ArtifactsReadLinesOutput>;
+};
+type ArtifactResolverOps = {
+  resolve(input: ArtifactResolveInput): Promise<ResolvedArtifact>;
+};
+type ArtifactsClientOps = ArtifactsOps & ArtifactResolverOps;
+declare const artifactsBackendSchema: z.ZodObject<{
+  create: z.ZodCustom<(input: ArtifactsCreateInput) => Promise<ArtifactsCreateOutput>, (input: ArtifactsCreateInput) => Promise<ArtifactsCreateOutput>>;
+  readRange: z.ZodCustom<(input: ArtifactsReadRangeInput) => Promise<ArtifactsReadRangeOutput>, (input: ArtifactsReadRangeInput) => Promise<ArtifactsReadRangeOutput>>;
+  readLines: z.ZodCustom<(input: ArtifactsReadLinesInput) => Promise<ArtifactsReadLinesOutput>, (input: ArtifactsReadLinesInput) => Promise<ArtifactsReadLinesOutput>>;
+  resolve: z.ZodOptional<z.ZodCustom<(input: ArtifactResolveInput) => Promise<ResolvedArtifact>, (input: ArtifactResolveInput) => Promise<ResolvedArtifact>>>;
+}, z.core.$strip>;
+declare const objectArtifactsAuthSchema: z.ZodObject<{
+  provider: z.ZodLiteral<"object">;
+  storage: z.ZodObject<{
+    access_key_id: z.ZodString;
+    secret_access_key: z.ZodString;
+    region: z.ZodString;
+    bucket: z.ZodString;
+    endpoint: z.ZodOptional<z.ZodURL>;
+    session_token: z.ZodOptional<z.ZodString>;
+    key_prefix: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const hostArtifactsAuthSchema: z.ZodObject<{
+  provider: z.ZodLiteral<"host">;
+  backend: z.ZodObject<{
+    create: z.ZodCustom<(input: ArtifactsCreateInput) => Promise<ArtifactsCreateOutput>, (input: ArtifactsCreateInput) => Promise<ArtifactsCreateOutput>>;
+    readRange: z.ZodCustom<(input: ArtifactsReadRangeInput) => Promise<ArtifactsReadRangeOutput>, (input: ArtifactsReadRangeInput) => Promise<ArtifactsReadRangeOutput>>;
+    readLines: z.ZodCustom<(input: ArtifactsReadLinesInput) => Promise<ArtifactsReadLinesOutput>, (input: ArtifactsReadLinesInput) => Promise<ArtifactsReadLinesOutput>>;
+    resolve: z.ZodOptional<z.ZodCustom<(input: ArtifactResolveInput) => Promise<ResolvedArtifact>, (input: ArtifactResolveInput) => Promise<ResolvedArtifact>>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const artifactsAuthSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  provider: z.ZodLiteral<"object">;
+  storage: z.ZodObject<{
+    access_key_id: z.ZodString;
+    secret_access_key: z.ZodString;
+    region: z.ZodString;
+    bucket: z.ZodString;
+    endpoint: z.ZodOptional<z.ZodURL>;
+    session_token: z.ZodOptional<z.ZodString>;
+    key_prefix: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  provider: z.ZodLiteral<"host">;
+  backend: z.ZodObject<{
+    create: z.ZodCustom<(input: ArtifactsCreateInput) => Promise<ArtifactsCreateOutput>, (input: ArtifactsCreateInput) => Promise<ArtifactsCreateOutput>>;
+    readRange: z.ZodCustom<(input: ArtifactsReadRangeInput) => Promise<ArtifactsReadRangeOutput>, (input: ArtifactsReadRangeInput) => Promise<ArtifactsReadRangeOutput>>;
+    readLines: z.ZodCustom<(input: ArtifactsReadLinesInput) => Promise<ArtifactsReadLinesOutput>, (input: ArtifactsReadLinesInput) => Promise<ArtifactsReadLinesOutput>>;
+    resolve: z.ZodOptional<z.ZodCustom<(input: ArtifactResolveInput) => Promise<ResolvedArtifact>, (input: ArtifactResolveInput) => Promise<ResolvedArtifact>>>;
+  }, z.core.$strip>;
+}, z.core.$strip>], "provider">;
+type ArtifactsAuth = z.infer<typeof artifactsAuthSchema>;
+type ObjectArtifactsAuth = z.infer<typeof objectArtifactsAuthSchema>;
+type HostArtifactsAuth = z.infer<typeof hostArtifactsAuthSchema>;
+//#endregion
+//#region src/modules/artifacts/client.d.ts
+declare class ArtifactsClient implements ArtifactsClientOps {
+  #private;
+  constructor(ops: ArtifactsClientOps);
+  static fromContext(ctx: ToolContext): ArtifactsClient;
+  static fromAuth(auth: ArtifactsAuth, ctx?: ToolContext): ArtifactsClient;
+  create(input: ArtifactsCreateInput): Promise<{
+    artifact: {
+      store: "host" | "object";
+      key: string;
+      media_type?: string | undefined;
+      filename?: string | undefined;
+      byte_length?: number | undefined;
+    };
+  }>;
+  readRange(input: ArtifactsReadRangeInput): Promise<{
+    source: {
+      store: "host" | "object";
+      key: string;
+      media_type?: string | undefined;
+      filename?: string | undefined;
+      byte_length?: number | undefined;
+    };
+    body_base64: string;
+    start_byte: number;
+    end_byte: number;
+    total_bytes?: number | undefined;
+    media_type?: string | undefined;
+  }>;
+  readLines(input: ArtifactsReadLinesInput): Promise<{
+    source: {
+      store: "host" | "object";
+      key: string;
+      media_type?: string | undefined;
+      filename?: string | undefined;
+      byte_length?: number | undefined;
+    };
+    text: string;
+    start_line: number;
+    end_line: number;
+    total_lines: number;
+  }>;
+  resolve(input: ArtifactResolveInput): Promise<ResolvedArtifact>;
+}
+//#endregion
+//#region src/modules/artifacts/module.d.ts
+declare const artifactsCreateTool: ToolDefinition<{
+  key: string;
+  body: string;
+  encoding: "base64" | "utf8";
+  media_type?: string | undefined;
+  filename?: string | undefined;
+}, {
+  artifact: {
+    store: "host" | "object";
+    key: string;
+    media_type?: string | undefined;
+    filename?: string | undefined;
+    byte_length?: number | undefined;
+  };
+}>;
+declare const artifactsReadRangeTool: ToolDefinition<{
+  source: {
+    store: "host" | "object";
+    key: string;
+    media_type?: string | undefined;
+    filename?: string | undefined;
+    byte_length?: number | undefined;
+  };
+  start_byte: number;
+  end_byte: number;
+}, {
+  source: {
+    store: "host" | "object";
+    key: string;
+    media_type?: string | undefined;
+    filename?: string | undefined;
+    byte_length?: number | undefined;
+  };
+  body_base64: string;
+  start_byte: number;
+  end_byte: number;
+  total_bytes?: number | undefined;
+  media_type?: string | undefined;
+}>;
+declare const artifactsReadLinesTool: ToolDefinition<{
+  source: {
+    store: "host" | "object";
+    key: string;
+    media_type?: string | undefined;
+    filename?: string | undefined;
+    byte_length?: number | undefined;
+  };
+  start_line: number;
+  end_line: number;
+}, {
+  source: {
+    store: "host" | "object";
+    key: string;
+    media_type?: string | undefined;
+    filename?: string | undefined;
+    byte_length?: number | undefined;
+  };
+  text: string;
+  start_line: number;
+  end_line: number;
+  total_lines: number;
+}>;
+declare const artifactsModule: ModuleDefinition<{
+  provider: "object";
+  storage: {
+    access_key_id: string;
+    secret_access_key: string;
+    region: string;
+    bucket: string;
+    endpoint?: string | undefined;
+    session_token?: string | undefined;
+    key_prefix?: string | undefined;
+  };
+} | {
+  provider: "host";
+  backend: {
+    create: (input: ArtifactsCreateInput) => Promise<ArtifactsCreateOutput>;
+    readRange: (input: ArtifactsReadRangeInput) => Promise<ArtifactsReadRangeOutput>;
+    readLines: (input: ArtifactsReadLinesInput) => Promise<ArtifactsReadLinesOutput>;
+    resolve?: ((input: ArtifactResolveInput) => Promise<ResolvedArtifact>) | undefined;
+  };
+}>;
+//#endregion
+//#region src/modules/artifacts/providers/host.d.ts
+declare class HostArtifactsProvider implements ArtifactsClientOps {
+  #private;
+  constructor(auth: HostArtifactsAuth);
+  create(input: ArtifactsCreateInput): Promise<ArtifactsCreateOutput>;
+  readRange(input: ArtifactsReadRangeInput): Promise<ArtifactsReadRangeOutput>;
+  readLines(input: ArtifactsReadLinesInput): Promise<ArtifactsReadLinesOutput>;
+  resolve(input: ArtifactResolveInput): Promise<ResolvedArtifact>;
+}
+//#endregion
+//#region src/modules/artifacts/providers/object.d.ts
+type ObjectArtifactsProviderOptions = Pick<HttpServiceOptions, 'fetch' | 'signal'>;
+declare class ObjectArtifactsProvider implements ArtifactsClientOps {
+  #private;
+  constructor(auth: ObjectArtifactsAuth, options?: ObjectArtifactsProviderOptions);
+  create(input: ArtifactsCreateInput): Promise<ArtifactsCreateOutput>;
+  readRange(input: ArtifactsReadRangeInput): Promise<ArtifactsReadRangeOutput>;
+  readLines(input: ArtifactsReadLinesInput): Promise<ArtifactsReadLinesOutput>;
+  resolve(input: ArtifactResolveInput): Promise<ResolvedArtifact>;
+}
+//#endregion
+export { type ArtifactRef, type ArtifactResolveInput, type ArtifactResolverOps, type ArtifactsAuth, ArtifactsClient, type ArtifactsClientOps, type ArtifactsCreateInput, type ArtifactsCreateOutput, type ArtifactsOps, type ArtifactsReadLinesInput, type ArtifactsReadLinesOutput, type ArtifactsReadRangeInput, type ArtifactsReadRangeOutput, type HostArtifactsAuth, HostArtifactsProvider, MAX_ARTIFACT_CREATE_BYTES, MAX_ARTIFACT_INLINE_CHARS, MAX_ARTIFACT_READ_BYTES, type ObjectArtifactsAuth, ObjectArtifactsProvider, type ObjectArtifactsProviderOptions, type ResolvedArtifact, artifactRefSchema, artifactResolveInputSchema, artifactsAuthSchema, artifactsBackendSchema, artifactsCreateInputSchema, artifactsCreateOutputSchema, artifactsCreateTool, artifactsModule, artifactsReadLinesInputSchema, artifactsReadLinesOutputSchema, artifactsReadLinesTool, artifactsReadRangeInputSchema, artifactsReadRangeOutputSchema, artifactsReadRangeTool, findArtifactRefs, hostArtifactsAuthSchema, objectArtifactsAuthSchema, resolvedArtifactSchema };
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/artifacts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/modules/artifacts/contracts.ts","../../../src/modules/artifacts/client.ts","../../../src/modules/artifacts/module.ts","../../../src/modules/artifacts/providers/host.ts","../../../src/modules/artifacts/providers/object.ts"],"mappings":"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"}

package/dist/modules/artifacts/index.js

@@ -0,0 +1,348 @@
+import { t as ToolError } from "../../errors-DoSpNHvs.js";
+import { n as defineModule, r as defineTool } from "../../define-CvpJ_pNP.js";
+import { n as requireAuth } from "../../provider-CgDAlg6K.js";
+import { n as findArtifactRefs, t as artifactRefSchema } from "../../artifact-D064mHfK.js";
+import { n as bytesToBase64, o as utf8ToBytes, r as bytesToUtf8, t as base64ToBytes } from "../../bytes-BxpimpQx.js";
+import { _ as MAX_OBJECT_BYTES, m as s3AuthSchema, p as S3Client } from "../../s3-CsOaPWMP.js";
+import { r as mediaTypeFromPath } from "../../content-type-CORxaxcv.js";
+import { isFunction } from "es-toolkit";
+import { z } from "zod";
+//#region src/modules/artifacts/contracts.ts
+/**
+* ArtifactRef creation and bounded read contracts.
+* Host-mapped and object-store backends share the same model-facing verbs.
+*/
+const MAX_ARTIFACT_READ_BYTES = MAX_OBJECT_BYTES;
+const MAX_ARTIFACT_CREATE_BYTES = MAX_OBJECT_BYTES;
+const MAX_ARTIFACT_INLINE_CHARS = Math.ceil(MAX_ARTIFACT_CREATE_BYTES * 4 / 3) + 4;
+const artifactsCreateInputSchema = z.object({
+	key: z.string().min(1).max(1024).describe("Destination key for the new artifact"),
+	body: z.string().max(MAX_ARTIFACT_INLINE_CHARS).describe("Artifact body encoded as specified by encoding"),
+	encoding: z.enum(["utf8", "base64"]).describe("How body is encoded"),
+	media_type: z.string().min(1).max(200).optional().describe("MIME type when known"),
+	filename: z.string().min(1).max(512).optional().describe("Display filename when different from the key")
+});
+const artifactsCreateOutputSchema = z.object({ artifact: artifactRefSchema.describe("Reference to the created artifact") });
+const artifactsReadRangeInputSchema = z.object({
+	source: artifactRefSchema.describe("Artifact to read"),
+	start_byte: z.int().min(0).describe("Inclusive zero-based start byte"),
+	end_byte: z.int().min(0).describe("Inclusive zero-based end byte")
+}).superRefine((input, ctx) => {
+	const byteLength = input.end_byte - input.start_byte + 1;
+	if (byteLength < 1) ctx.addIssue({
+		code: "custom",
+		path: ["end_byte"],
+		message: "end_byte must be greater than or equal to start_byte"
+	});
+	if (byteLength > MAX_ARTIFACT_READ_BYTES) ctx.addIssue({
+		code: "custom",
+		path: ["end_byte"],
+		message: `Byte range cannot exceed ${MAX_ARTIFACT_READ_BYTES} bytes`
+	});
+});
+const artifactsReadRangeOutputSchema = z.object({
+	source: artifactRefSchema,
+	body_base64: z.string().describe("Requested bytes encoded as base64"),
+	start_byte: z.int().min(0),
+	end_byte: z.int().min(0),
+	total_bytes: z.int().min(0).optional(),
+	media_type: z.string().optional()
+});
+const artifactsReadLinesInputSchema = z.object({
+	source: artifactRefSchema.describe("UTF-8 text artifact to read"),
+	start_line: z.int().min(1).describe("Inclusive one-based start line"),
+	end_line: z.int().min(1).describe("Inclusive one-based end line")
+}).refine((input) => input.end_line >= input.start_line, {
+	path: ["end_line"],
+	message: "end_line must be greater than or equal to start_line"
+});
+const artifactsReadLinesOutputSchema = z.object({
+	source: artifactRefSchema,
+	text: z.string().describe("Selected UTF-8 lines"),
+	start_line: z.int().min(1),
+	end_line: z.int().min(1),
+	total_lines: z.int().min(0)
+});
+const artifactResolveInputSchema = z.object({
+	source: artifactRefSchema,
+	max_bytes: z.int().min(0)
+});
+const resolvedArtifactSchema = z.object({
+	artifact: artifactRefSchema,
+	bytes: z.custom((value) => value instanceof Uint8Array, "bytes must be a Uint8Array")
+});
+const artifactsBackendSchema = z.object({
+	create: z.custom(isFunction, "create must be a function"),
+	readRange: z.custom(isFunction, "readRange must be a function"),
+	readLines: z.custom(isFunction, "readLines must be a function"),
+	resolve: z.custom(isFunction, "resolve must be a function").optional()
+});
+const objectArtifactsAuthSchema = z.object({
+	provider: z.literal("object"),
+	storage: s3AuthSchema.describe("S3-compatible object storage for ArtifactRef bytes")
+});
+const hostArtifactsAuthSchema = z.object({
+	provider: z.literal("host"),
+	backend: artifactsBackendSchema.describe("Host artifact operations for host-mapped ArtifactRefs")
+});
+const artifactsAuthSchema = z.discriminatedUnion("provider", [objectArtifactsAuthSchema, hostArtifactsAuthSchema]);
+//#endregion
+//#region src/modules/artifacts/providers/host.ts
+function requireHostStore(store) {
+	if (store !== "host") throw new ToolError("The host artifact provider only resolves host-mapped references", { code: "unsupported" });
+}
+var HostArtifactsProvider = class {
+	#backend;
+	constructor(auth) {
+		this.#backend = auth.backend;
+	}
+	async create(input) {
+		const output = artifactsCreateOutputSchema.parse(await this.#backend.create(input));
+		requireHostStore(output.artifact.store);
+		return output;
+	}
+	async readRange(input) {
+		requireHostStore(input.source.store);
+		return artifactsReadRangeOutputSchema.parse(await this.#backend.readRange(input));
+	}
+	async readLines(input) {
+		requireHostStore(input.source.store);
+		return artifactsReadLinesOutputSchema.parse(await this.#backend.readLines(input));
+	}
+	async resolve(input) {
+		requireHostStore(input.source.store);
+		if (input.source.byte_length !== void 0 && input.source.byte_length > input.max_bytes) throw new ToolError("Artifact exceeds resolution limit", {
+			code: "too_large",
+			details: {
+				max_bytes: input.max_bytes,
+				content_length: input.source.byte_length
+			}
+		});
+		if (!this.#backend.resolve) throw new ToolError("The host artifact backend does not support byte resolution", { code: "unsupported" });
+		const output = resolvedArtifactSchema.parse(await this.#backend.resolve(input));
+		requireHostStore(output.artifact.store);
+		if (output.artifact.key !== input.source.key) throw new ToolError("The host artifact backend resolved a different artifact", { code: "internal" });
+		if (output.bytes.byteLength > input.max_bytes) throw new ToolError("Artifact exceeds resolution limit", {
+			code: "too_large",
+			details: {
+				max_bytes: input.max_bytes,
+				content_length: output.bytes.byteLength
+			}
+		});
+		return {
+			artifact: {
+				...input.source,
+				...output.artifact,
+				byte_length: output.bytes.byteLength
+			},
+			bytes: output.bytes
+		};
+	}
+};
+//#endregion
+//#region src/modules/artifacts/providers/object.ts
+function requireObjectSource(store) {
+	if (store !== "object") throw new ToolError("The object artifact provider only resolves object-store references", { code: "unsupported" });
+}
+function artifactBytes(input) {
+	const bytes = input.encoding === "base64" ? base64ToBytes(input.body) : utf8ToBytes(input.body);
+	if (bytes.byteLength > MAX_ARTIFACT_CREATE_BYTES) throw new ToolError("Artifact body exceeds create limit", {
+		code: "too_large",
+		details: {
+			max_bytes: MAX_ARTIFACT_CREATE_BYTES,
+			content_length: bytes.byteLength
+		}
+	});
+	return bytes;
+}
+function textLines(text) {
+	return text.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+var ObjectArtifactsProvider = class {
+	#storage;
+	constructor(auth, options = {}) {
+		this.#storage = new S3Client(auth.storage, options);
+	}
+	async create(input) {
+		const bytes = artifactBytes(input);
+		const mediaType = input.media_type ?? mediaTypeFromPath(input.filename ?? input.key);
+		await this.#storage.putBytes(input.key, bytes, mediaType);
+		return { artifact: artifactRefSchema.parse({
+			store: "object",
+			key: input.key,
+			byte_length: bytes.byteLength,
+			...mediaType && { media_type: mediaType },
+			...input.filename && { filename: input.filename }
+		}) };
+	}
+	async readRange(input) {
+		requireObjectSource(input.source.store);
+		const result = await this.#storage.getBytesRange(input.source.key, {
+			start_byte: input.start_byte,
+			end_byte: input.end_byte
+		});
+		return {
+			source: input.source,
+			body_base64: bytesToBase64(result.bytes),
+			start_byte: result.start_byte,
+			end_byte: result.end_byte,
+			...result.total_bytes !== void 0 && { total_bytes: result.total_bytes },
+			...result.content_type && { media_type: result.content_type }
+		};
+	}
+	async readLines(input) {
+		requireObjectSource(input.source.store);
+		const lines = textLines(bytesToUtf8(await this.#storage.getBytes(input.source.key, { maxBytes: MAX_ARTIFACT_READ_BYTES })));
+		if (input.start_line > lines.length) throw new ToolError("start_line is beyond the end of the artifact", {
+			code: "bad_input",
+			details: {
+				start_line: input.start_line,
+				total_lines: lines.length
+			}
+		});
+		const selected = lines.slice(input.start_line - 1, input.end_line);
+		return {
+			source: input.source,
+			text: selected.join("\n"),
+			start_line: input.start_line,
+			end_line: input.start_line + selected.length - 1,
+			total_lines: lines.length
+		};
+	}
+	async resolve(input) {
+		requireObjectSource(input.source.store);
+		if (input.source.byte_length !== void 0 && input.source.byte_length > input.max_bytes) throw new ToolError("Artifact exceeds resolution limit", {
+			code: "too_large",
+			details: {
+				max_bytes: input.max_bytes,
+				content_length: input.source.byte_length
+			}
+		});
+		const head = await this.#storage.head({ key: input.source.key });
+		if (!head.exists) throw new ToolError("Artifact not found", { code: "not_found" });
+		if (head.content_length !== void 0 && head.content_length > input.max_bytes) throw new ToolError("Artifact exceeds resolution limit", {
+			code: "too_large",
+			details: {
+				max_bytes: input.max_bytes,
+				content_length: head.content_length
+			}
+		});
+		const bytes = await this.#storage.getBytes(input.source.key, { maxBytes: input.max_bytes });
+		return {
+			artifact: artifactRefSchema.parse({
+				...input.source,
+				...!input.source.media_type && head.content_type && { media_type: head.content_type },
+				byte_length: bytes.byteLength
+			}),
+			bytes
+		};
+	}
+};
+//#endregion
+//#region src/modules/artifacts/client.ts
+function transportOptions(ctx) {
+	return {
+		...ctx.fetch && { fetch: ctx.fetch },
+		...ctx.signal && { signal: ctx.signal }
+	};
+}
+function providerFor(auth, ctx) {
+	switch (auth.provider) {
+		case "object": return new ObjectArtifactsProvider(auth, transportOptions(ctx));
+		case "host": return new HostArtifactsProvider(auth);
+	}
+}
+var ArtifactsClient = class ArtifactsClient {
+	#ops;
+	constructor(ops) {
+		this.#ops = ops;
+	}
+	static fromContext(ctx) {
+		const auth = requireAuth(ctx, artifactsAuthSchema);
+		return new ArtifactsClient(providerFor(auth, ctx));
+	}
+	static fromAuth(auth, ctx = {}) {
+		return new ArtifactsClient(providerFor(auth, ctx));
+	}
+	create(input) {
+		return this.#ops.create(input);
+	}
+	readRange(input) {
+		return this.#ops.readRange(input);
+	}
+	readLines(input) {
+		return this.#ops.readLines(input);
+	}
+	async resolve(input) {
+		const parsedInput = artifactResolveInputSchema.parse(input);
+		const output = resolvedArtifactSchema.parse(await this.#ops.resolve(parsedInput));
+		if (output.bytes.byteLength > parsedInput.max_bytes) throw new ToolError("Artifact exceeds resolution limit", {
+			code: "too_large",
+			details: {
+				max_bytes: parsedInput.max_bytes,
+				content_length: output.bytes.byteLength
+			}
+		});
+		return {
+			artifact: {
+				...output.artifact,
+				byte_length: output.bytes.byteLength
+			},
+			bytes: output.bytes
+		};
+	}
+};
+//#endregion
+//#region src/modules/artifacts/module.ts
+const artifactsCreateTool = defineTool({
+	id: "artifacts-create",
+	name: "createArtifact",
+	description: "Persist small, already-serialized UTF-8 or base64 content and return its ArtifactRef. Use for raw bytes or text when no structured builder is required. Do not use this to invent DOCX, XLSX, PPTX, PDF, or image formats.",
+	inputSchema: artifactsCreateInputSchema,
+	outputSchema: artifactsCreateOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => ArtifactsClient.fromContext(ctx).create(input)
+});
+const artifactsReadRangeTool = defineTool({
+	id: "artifacts-read-range",
+	name: "readArtifactRange",
+	description: "Read an explicit inclusive byte range from an existing ArtifactRef as base64. Use for bounded binary inspection or chunked transfer, not for understanding a supported document when a format-aware reader is available.",
+	inputSchema: artifactsReadRangeInputSchema,
+	outputSchema: artifactsReadRangeOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => ArtifactsClient.fromContext(ctx).readRange(input)
+});
+const artifactsReadLinesTool = defineTool({
+	id: "artifacts-read-lines",
+	name: "readArtifactLines",
+	description: "Read an explicit inclusive line range from a UTF-8 text artifact. Use for bounded inspection instead of loading the whole file into context.",
+	inputSchema: artifactsReadLinesInputSchema,
+	outputSchema: artifactsReadLinesOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => ArtifactsClient.fromContext(ctx).readLines(input)
+});
+const artifactsModule = defineModule({
+	id: "artifacts",
+	title: "Artifacts",
+	description: "Persist small serialized content and inspect bounded byte or text ranges. ArtifactRef is the handoff between tools; structured document creation belongs to purpose-built builders.",
+	runtime: "both",
+	auth: {
+		type: "custom",
+		schema: artifactsAuthSchema
+	},
+	categories: ["storage", "artifacts"],
+	classification: "pii",
+	tags: ["artifact-ref", "object-store"],
+	tools: [
+		artifactsCreateTool,
+		artifactsReadRangeTool,
+		artifactsReadLinesTool
+	]
+});
+//#endregion
+export { ArtifactsClient, HostArtifactsProvider, MAX_ARTIFACT_CREATE_BYTES, MAX_ARTIFACT_INLINE_CHARS, MAX_ARTIFACT_READ_BYTES, ObjectArtifactsProvider, artifactRefSchema, artifactResolveInputSchema, artifactsAuthSchema, artifactsBackendSchema, artifactsCreateInputSchema, artifactsCreateOutputSchema, artifactsCreateTool, artifactsModule, artifactsReadLinesInputSchema, artifactsReadLinesOutputSchema, artifactsReadLinesTool, artifactsReadRangeInputSchema, artifactsReadRangeOutputSchema, artifactsReadRangeTool, findArtifactRefs, hostArtifactsAuthSchema, objectArtifactsAuthSchema, resolvedArtifactSchema };
+
+//# sourceMappingURL=index.js.map