결과 정의하기

ant files upload --file /tmp/rubric.md

import time
from pathlib import Path

from anthropic import Anthropic

client = Anthropic()

RUBRIC = """# DCF Model Rubric

## Revenue Projections
- Uses historical revenue data from the last 5 fiscal years
- Projects revenue for at least 5 years forward

## Output Quality
- All figures are in a single .xlsx file with clearly labeled sheets
"""
Path("/tmp/rubric.md").write_text(RUBRIC)

rubric = client.files.upload(file=Path("/tmp/rubric.md"))
print(f"Uploaded rubric: {rubric.id}")

import { writeFile, readFile } from "node:fs/promises";

import Anthropic from "@anthropic-ai/sdk";
import { toFile } from "@anthropic-ai/sdk";

const client = new Anthropic();

const RUBRIC = `# DCF Model Rubric

## Revenue Projections
- Uses historical revenue data from the last 5 fiscal years
- Projects revenue for at least 5 years forward

## Output Quality
- All figures are in a single .xlsx file with clearly labeled sheets
`;
await writeFile("/tmp/rubric.md", RUBRIC);

const rubric = await client.files.upload({
  file: await toFile(readFile("/tmp/rubric.md"), "/tmp/rubric.md"),
});
console.log(`Uploaded rubric: ${rubric.id}`);

using Anthropic;
using Anthropic.Models.Beta.Agents;
using Anthropic.Models.Beta.Environments;
using Anthropic.Models.Beta.Sessions;
using Anthropic.Models.Beta.Sessions.Events;
using Anthropic.Models.Files;

var client = new AnthropicClient();

const string Rubric = """
    # DCF Model Rubric

    ## Revenue Projections
    - Uses historical revenue data from the last 5 fiscal years
    - Projects revenue for at least 5 years forward

    ## Output Quality
    - All figures are in a single .xlsx file with clearly labeled sheets
    """;
await File.WriteAllTextAsync("/tmp/rubric.md", Rubric);

var rubric = await client.Files.Upload(new()
{
    File = File.OpenRead("/tmp/rubric.md"),
});
Console.WriteLine($"Uploaded rubric: {rubric.ID}");

package main

import (
	"context"
	"fmt"
	"io"
	"os"
	"time"

	"github.com/anthropics/anthropic-sdk-go"
)

const rubric = `# DCF Model Rubric

## Revenue Projections
- Uses historical revenue data from the last 5 fiscal years
- Projects revenue for at least 5 years forward

## Output Quality
- All figures are in a single .xlsx file with clearly labeled sheets
`

func main() {
	ctx := context.Background()
	client := anthropic.NewClient()

	if err := os.WriteFile("/tmp/rubric.md", []byte(rubric), 0o644); err != nil {
		panic(err)
	}

	f, err := os.Open("/tmp/rubric.md")
	if err != nil {
		panic(err)
	}

	uploaded, err := client.Files.Upload(ctx, anthropic.FileUploadParams{
		File: anthropic.File(f, "rubric.md", "text/markdown"),
	})
	if err != nil {
		panic(err)
	}
	fmt.Printf("Uploaded rubric: %s\n", uploaded.ID)

import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.http.HttpResponse;
import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.agents.AgentCreateParams;
import com.anthropic.models.beta.agents.BetaManagedAgentsAgentToolset20260401Params;
import com.anthropic.models.beta.agents.BetaManagedAgentsModel;
import com.anthropic.models.beta.environments.BetaCloudConfigParams;
import com.anthropic.models.beta.environments.EnvironmentCreateParams;
import com.anthropic.models.beta.files.FileListParams;
import com.anthropic.models.beta.sessions.SessionCreateParams;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsTextRubricParams;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserDefineOutcomeEventParams;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserInterruptEventParams;
import com.anthropic.models.beta.sessions.events.EventSendParams;
import com.anthropic.models.files.FileUploadParams;

import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

void main() throws Exception {
    var client = AnthropicOkHttpClient.fromEnv();

    var RUBRIC = """
        # DCF Model Rubric

        ## Revenue Projections
        - Uses historical revenue data from the last 5 fiscal years
        - Projects revenue for at least 5 years forward

        ## Output Quality
        - All figures are in a single .xlsx file with clearly labeled sheets
        """;
    Files.writeString(Path.of("/tmp/rubric.md"), RUBRIC);

    var rubric = client.files().upload(
        FileUploadParams.builder()
            .file(Path.of("/tmp/rubric.md"))
            .build());
    IO.println("Uploaded rubric: " + rubric.id());

use Anthropic\Client;
use Anthropic\Core\FileParam;

$client = new Client();

$rubricText = <<<'MD'
# DCF Model Rubric

## Revenue Projections
- Uses historical revenue data from the last 5 fiscal years
- Projects revenue for at least 5 years forward

## Output Quality
- All figures are in a single .xlsx file with clearly labeled sheets
MD;
file_put_contents('/tmp/rubric.md', $rubricText);

$rubric = $client->files->upload(
    file: FileParam::fromResource(fopen('/tmp/rubric.md', 'r'), contentType: 'text/markdown'),
);
echo "Uploaded rubric: {$rubric->id}\n";

require "anthropic"
require "pathname"

client = Anthropic::Client.new

RUBRIC = <<~MD
  # DCF Model Rubric

  ## Revenue Projections
  - Uses historical revenue data from the last 5 fiscal years
  - Projects revenue for at least 5 years forward

  ## Output Quality
  - All figures are in a single .xlsx file with clearly labeled sheets
MD
File.write("/tmp/rubric.md", RUBRIC)

rubric = client.files.upload(file: Pathname.new("/tmp/rubric.md"))
puts "Uploaded rubric: #{rubric.id}"

ant beta:sessions retrieve --session-id "$SESSION_ID"

session = client.beta.sessions.retrieve(session.id)

for outcome in session.outcome_evaluations:
    print(f"{outcome.outcome_id}: {outcome.result}")
    # outc_01a...: satisfied

const retrieved = await client.beta.sessions.retrieve(session.id);

for (const outcome of retrieved.outcome_evaluations) {
  console.log(`${outcome.outcome_id}: ${outcome.result}`);
  // outc_01a...: satisfied
}

session = await client.Beta.Sessions.Retrieve(session.ID);

foreach (var outcome in session.OutcomeEvaluations)
{
    Console.WriteLine($"{outcome.OutcomeID}: {outcome.Result}");
    // outc_01a...: satisfied
}

session, err = client.Beta.Sessions.Get(ctx, session.ID, anthropic.BetaSessionGetParams{})
if err != nil {
	panic(err)
}

for _, outcome := range session.OutcomeEvaluations {
	fmt.Printf("%s: %s\n", outcome.OutcomeID, outcome.Result)
	// outc_01a...: satisfied
}

var retrieved = client.beta().sessions().retrieve(session.id());

for (var outcome : retrieved.outcomeEvaluations()) {
    IO.println(outcome.outcomeId() + ": " + outcome.result());
    // outc_01a...: satisfied
}

$session = $client->beta->sessions->retrieve($session->id);

foreach ($session->outcomeEvaluations as $outcome) {
    echo "{$outcome->outcomeID}: {$outcome->result}\n";
    // outc_01a...: satisfied
}

session = client.beta.sessions.retrieve(session.id)

session.outcome_evaluations.each do
  puts "#{it.outcome_id}: #{it.result}"
  # outc_01a...: satisfied
end

Download a file

FILE_ID=$(curl -fsSL "https://api.anthropic.com/v1/files?scope_id=$SESSION_ID"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: managed-agents-2026-04-01" | jq -r '.data[0].id // empty') if [[ -n $FILE_ID ]]; then curl -fsSL "https://api.anthropic.com/v1/files/$FILE_ID/content"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: managed-agents-2026-04-01"
-o /tmp/output.txt fi

```bash CLI
# List files produced by this session
# scope_id filtering requires the managed-agents beta on the files request
ant beta:files list --scope-id "$SESSION_ID" --beta managed-agents-2026-04-01

# Download a file
FILE_ID=$(ant beta:files list --scope-id "$SESSION_ID" \
  --beta managed-agents-2026-04-01 \
  --transform 'data[0].id' --raw-output)
if [[ -n $FILE_ID ]]; then
  ant files download --file-id "$FILE_ID" --output /tmp/output.txt
fi

# List files produced by this session
# scope_id filtering requires the managed-agents beta on the files request
files = client.beta.files.list(scope_id=session.id, betas=["managed-agents-2026-04-01"])
for file in files:
    print(file.id, file.filename)

# Download a file
if files.data:
    content = client.files.download(files.data[0].id)
    content.write_to_file("/tmp/output.txt")

// List files produced by this session
// scope_id filtering requires the managed-agents beta on the files request
const files = await client.beta.files.list({
  scope_id: session.id,
  betas: ["managed-agents-2026-04-01"],
});
for (const file of files.data) {
  console.log(file.id, file.filename);
}

// Download a file
if (files.data.length > 0) {
  const content = await client.files.download(files.data[0].id);
  await writeFile("/tmp/output.txt", new Uint8Array(await content.arrayBuffer()));
}

// List files produced by this session
// (scope_id filtering requires the managed-agents beta on the files request)
var files = await client.Beta.Files.List(new()
{
    ScopeID = session.ID,
    Betas = ["managed-agents-2026-04-01"],
});
foreach (var file in files.Items)
{
    Console.WriteLine($"{file.ID} {file.Filename}");
}

// Download a file
if (files.Items.Count > 0)
{
    using var download = await client.Files.Download(files.Items[0].ID);
    await using var output = File.Create("/tmp/output.txt");
    await (await download.ReadAsStream()).CopyToAsync(output);
}

// List files produced by this session
// (scope_id filtering requires the managed-agents beta on the files request)
files, err := client.Beta.Files.List(ctx, anthropic.BetaFileListParams{
	ScopeID: anthropic.String(session.ID),
	Betas:   []anthropic.AnthropicBeta{anthropic.AnthropicBetaManagedAgents2026_04_01},
})
if err != nil {
	panic(err)
}
for _, file := range files.Data {
	fmt.Println(file.ID, file.Filename)
}

// Download a file
if len(files.Data) > 0 {
	resp, err := client.Files.Download(ctx, files.Data[0].ID, anthropic.FileDownloadParams{})
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	out, err := os.Create("/tmp/output.txt")
	if err != nil {
		panic(err)
	}
	defer out.Close()
	if _, err := io.Copy(out, resp.Body); err != nil {
		panic(err)
	}
}

// List files produced by this session
// (scope_id filtering requires the managed-agents beta on the files request)
var files = client.beta().files().list(
    FileListParams.builder()
        .scopeId(session.id())
        .addBeta(AnthropicBeta.MANAGED_AGENTS_2026_04_01)
        .build());
for (var file : files.data()) {
    IO.println(file.id() + " " + file.filename());
}

// Download a file
if (!files.data().isEmpty()) {
    try (HttpResponse response = client.files().download(files.data().getFirst().id())) {
        try (InputStream body = response.body()) {
            Files.copy(body, Path.of("/tmp/output.txt"), StandardCopyOption.REPLACE_EXISTING);
        }
    }
}

// List files produced by this session
// scope_id filtering requires the managed-agents beta on the files request
$files = $client->beta->files->list(scopeID: $session->id, betas: ['managed-agents-2026-04-01']);
foreach ($files->getItems() as $file) {
    echo "{$file->id} {$file->filename}\n";
}

// Download a file
if (count($files->getItems()) > 0) {
    $content = $client->files->download($files->getItems()[0]->id);
    file_put_contents('/tmp/output.txt', $content);
}

# List files produced by this session
# scope_id filtering requires the managed-agents beta on the files request
files = client.beta.files.list(scope_id: session.id, betas: ["managed-agents-2026-04-01"])
files.data.each { |file| puts "#{file.id} #{file.filename}" }

# Download a file
if (first = files.data.first)
  content = client.files.download(first.id)
  File.binwrite("/tmp/output.txt", content.read)
end