import { T as TOOL_SCHEMAS, F as FileToolName, A as ApprovalConfig, d as FileReadToolName } from "../../packem_shared/approval.d-Bx1sTyT7.js";
export type { e as FileWriteToolName } from "../../packem_shared/approval.d-Bx1sTyT7.js";
import { UnknownContext, FunctionTool } from '@openai/agents';
import { e as executors } from "../../packem_shared/executors.d-Lb1t-i92.js";
import { F as Files } from "../../packem_shared/files.d-DJcRVSlV.js";
import 'zod';
import "../../packem_shared/storage.d-Cnjmzau5.js";
import 'node:stream';
import "../../packem_shared/types.d-DFh9698o.js";
import 'node:crypto';
import 'node:http';
import 'lru-cache';
/**
 * Per-tool overrides for `createResponsesFileTools`. `name`, `parameters`, and
 * `type` are intentionally not overridable — the contract that drives tool
 * behavior should not be patched at this layer.
 */
interface ResponsesToolOverrides {
  description?: string;
  strict?: boolean;
}
/**
 * Per-tool overrides for `createAgentsFileTools`. `name`, `parameters`,
 * `execute`, and `strict` are intentionally not overridable — the contract
 * that drives tool behavior should not be patched at this layer.
 */
interface AgentsToolOverrides {
  description?: string;
  needsApproval?: boolean;
}
type ListFilesOutput = Awaited<ReturnType<typeof executors.listFiles>>;
type SearchFilesOutput = Awaited<ReturnType<typeof executors.searchFiles>>;
type GetFileMetadataOutput = Awaited<ReturnType<typeof executors.getFileMetadata>>;
type DownloadFileOutput = Awaited<ReturnType<typeof executors.downloadFile>>;
type GetFileUrlOutput = Awaited<ReturnType<typeof executors.getFileUrl>>;
type UploadFileOutput = Awaited<ReturnType<typeof executors.uploadFile>>;
type DeleteFileOutput = Awaited<ReturnType<typeof executors.deleteFile>>;
type CopyFileOutput = Awaited<ReturnType<typeof executors.copyFile>>;
type SignUploadUrlOutput = Awaited<ReturnType<typeof executors.signUploadUrl>>;
type ListFilesParameters = typeof TOOL_SCHEMAS.listFiles.input;
type SearchFilesParameters = typeof TOOL_SCHEMAS.searchFiles.input;
type GetFileMetadataParameters = typeof TOOL_SCHEMAS.getFileMetadata.input;
type DownloadFileParameters = typeof TOOL_SCHEMAS.downloadFile.input;
type GetFileUrlParameters = typeof TOOL_SCHEMAS.getFileUrl.input;
type UploadFileParameters = typeof TOOL_SCHEMAS.uploadFile.input;
type DeleteFileParameters = typeof TOOL_SCHEMAS.deleteFile.input;
type CopyFileParameters = typeof TOOL_SCHEMAS.copyFile.input;
type SignUploadUrlParameters = typeof TOOL_SCHEMAS.signUploadUrl.input;
declare const agentsListFiles: (files: Files, { needsApproval }?: {
  needsApproval?: boolean;
}) => FunctionTool<UnknownContext, ListFilesParameters, ListFilesOutput>;
declare const agentsSearchFiles: (files: Files, { needsApproval }?: {
  needsApproval?: boolean;
}) => FunctionTool<UnknownContext, SearchFilesParameters, SearchFilesOutput>;
declare const agentsGetFileMetadata: (files: Files, { needsApproval }?: {
  needsApproval?: boolean;
}) => FunctionTool<UnknownContext, GetFileMetadataParameters, GetFileMetadataOutput>;
declare const agentsDownloadFile: (files: Files, { needsApproval }?: {
  needsApproval?: boolean;
}) => FunctionTool<UnknownContext, DownloadFileParameters, DownloadFileOutput>;
declare const agentsGetFileUrl: (files: Files, { needsApproval }?: {
  needsApproval?: boolean;
}) => FunctionTool<UnknownContext, GetFileUrlParameters, GetFileUrlOutput>;
declare const agentsUploadFile: (files: Files, { needsApproval }?: {
  needsApproval?: boolean;
}) => FunctionTool<UnknownContext, UploadFileParameters, UploadFileOutput>;
declare const agentsDeleteFile: (files: Files, { needsApproval }?: {
  needsApproval?: boolean;
}) => FunctionTool<UnknownContext, DeleteFileParameters, DeleteFileOutput>;
declare const agentsCopyFile: (files: Files, { needsApproval }?: {
  needsApproval?: boolean;
}) => FunctionTool<UnknownContext, CopyFileParameters, CopyFileOutput>;
declare const agentsSignUploadUrl: (files: Files, { needsApproval }?: {
  needsApproval?: boolean;
}) => FunctionTool<UnknownContext, SignUploadUrlParameters, SignUploadUrlOutput>;
interface AgentsFileTools {
  copyFile: ReturnType<typeof agentsCopyFile>;
  deleteFile: ReturnType<typeof agentsDeleteFile>;
  downloadFile: ReturnType<typeof agentsDownloadFile>;
  getFileMetadata: ReturnType<typeof agentsGetFileMetadata>;
  getFileUrl: ReturnType<typeof agentsGetFileUrl>;
  listFiles: ReturnType<typeof agentsListFiles>;
  searchFiles: ReturnType<typeof agentsSearchFiles>;
  signUploadUrl: ReturnType<typeof agentsSignUploadUrl>;
  uploadFile: ReturnType<typeof agentsUploadFile>;
}
type ReadOnlyAgentsFileTools = Pick<AgentsFileTools, FileReadToolName>;
interface AgentsFileToolsOptions {
  files: Files;
  overrides?: Partial<Record<FileToolName, AgentsToolOverrides>>;
  readOnly?: boolean;
  requireApproval?: ApprovalConfig;
}
/**
 * Create a set of storage tools shaped for the OpenAI Agents SDK (`@openai/agents`).
 *
 * Returns a record keyed by tool name — spread `Object.values()` into
 * `new Agent({ tools })`. Write tools require approval by default.
 * @example
 * ```ts
 * import { Agent, run } from "@openai/agents";
 * import { Files } from "@visulima/storage";
 * import { S3Storage } from "@visulima/storage/provider/aws";
 * import { createAgentsFileTools } from "@visulima/storage/ai/openai";
 *
 * const files = new Files({ adapter: new S3Storage({ bucket: "uploads" }) });
 * const tools = createAgentsFileTools({ files });
 *
 * const agent = new Agent({
 *   instructions: "Help the user manage their files.",
 *   name: "Files agent",
 *   tools: Object.values(tools),
 * });
 *
 * const result = await run(agent, "List my files.");
 * ```
 */
declare function createAgentsFileTools(options: AgentsFileToolsOptions & {
  readOnly: true;
}): ReadOnlyAgentsFileTools;
declare function createAgentsFileTools(options: AgentsFileToolsOptions & {
  readOnly?: false | undefined;
}): AgentsFileTools;
declare function createAgentsFileTools(options: AgentsFileToolsOptions): AgentsFileTools | ReadOnlyAgentsFileTools;
/**
 * A function-tool definition shaped for OpenAI's Responses API. Pass an
 * array of these to `openai.responses.create({ tools })`.
 */
interface ResponsesFunctionTool {
  description: string;
  name: string;
  parameters: Record<string, unknown>;
  strict: boolean;
  type: "function";
}
/**
 * A function call emitted by the Responses API in `response.output[]`.
 */
interface FunctionCallItem {
  arguments: string;
  call_id: string;
  name: string;
  type: "function_call";
}
/**
 * A function-call output item to append to the next `responses.create`
 * input alongside the original `function_call` item.
 */
interface FunctionCallOutputItem {
  call_id: string;
  output: string;
  type: "function_call_output";
}
interface ResponsesFileTools {
  /**
   * Function tool definitions. Pass directly to `openai.responses.create({ tools })`.
   */
  definitions: ResponsesFunctionTool[];
  /**
   * Execute a `function_call` item from the model's `response.output[]`.
   * Returns a `function_call_output` item ready to push into the next turn's input.
   *
   * Approval is **not** enforced. Check {@link ResponsesFileTools.needsApproval}
   * first if you want a human-in-the-loop gate.
   */
  execute: (call: FunctionCallItem) => Promise<FunctionCallOutputItem>;
  /**
   * Returns whether the named tool is approval-gated under this config.
   * Read tools always return `false`. Unknown names return `false`.
   */
  needsApproval: (name: string) => boolean;
}
interface ResponsesFileToolsOptions {
  files: Files;
  overrides?: Partial<Record<FileToolName, ResponsesToolOverrides>>;
  readOnly?: boolean;
  requireApproval?: ApprovalConfig;
}
/**
 * Create a set of storage tools shaped for OpenAI's Responses API (`openai.responses.create`).
 * @example
 * ```ts
 * import OpenAI from "openai";
 * import { Files } from "@visulima/storage";
 * import { S3Storage } from "@visulima/storage/provider/aws";
 * import { createResponsesFileTools } from "@visulima/storage/ai/openai";
 *
 * const client = new OpenAI();
 * const files = new Files({ adapter: new S3Storage({ bucket: "uploads" }) });
 * const ft = createResponsesFileTools({ files });
 *
 * const input: any[] = [{ role: "user", content: "List my files." }];
 * while (true) {
 *   const res = await client.responses.create({ model: "gpt-4.1", input, tools: ft.definitions });
 *   const calls = res.output.filter((o) => o.type === "function_call");
 *   if (calls.length === 0) break;
 *   for (const call of calls) {
 *     if (ft.needsApproval(call.name)) {
 *       // surface approval UX, then continue or break
 *     }
 *     input.push(call, await ft.execute(call));
 *   }
 * }
 * ```
 */
declare const createResponsesFileTools: ({ files, overrides, readOnly, requireApproval }: ResponsesFileToolsOptions) => ResponsesFileTools;
export { type AgentsFileTools, type AgentsFileToolsOptions, type AgentsToolOverrides,
/**
 * OpenAI adapter — exposes the shared tool definitions for two surfaces:
 * `createResponsesFileTools` for `openai.responses.create({ tools })`
 * (Responses API; requires the `openai` peer dependency >=5) and
 * `createAgentsFileTools` for `@openai/agents` (Agents SDK; requires
 * `@openai/agents` peer dependency).
 */
type ApprovalConfig, type FileReadToolName, type FileToolName, type FunctionCallItem, type FunctionCallOutputItem, type ReadOnlyAgentsFileTools, type ResponsesFileTools, type ResponsesFileToolsOptions, type ResponsesFunctionTool, type ResponsesToolOverrides, agentsCopyFile, agentsDeleteFile, agentsDownloadFile, agentsGetFileMetadata, agentsGetFileUrl, agentsListFiles, agentsSearchFiles, agentsSignUploadUrl, agentsUploadFile, createAgentsFileTools, createResponsesFileTools };