Skills

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "shell",
      environment: {
        type: "container_auto",
        skills: [
          { type: "skill_reference", skill_id: "<skill_id>" },
          { type: "skill_reference", skill_id: "<skill_id>", version: "2" },
        ],
      },
    },
  ],
  input:
    "Use the skills to add 144 and 377, then compute triangle area with base 9 height 13.",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22response = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "shell",
            "environment": {
                "type": "container_auto",
                "skills": [
                    {"type": "skill_reference", "skill_id": "<skill_id>"},
                    {
                        "type": "skill_reference",
                        "skill_id": "<skill_id>",
                        "version": "2",
                    },
                ],
            },
        }
    ],
    input="Use the skills to add 144 and 377, then compute triangle area with base 9 height 13.",
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolUnionParam{OfShell: &responses.FunctionShellToolParam{
		Environment: responses.FunctionShellToolEnvironmentUnionParam{OfContainerAuto: &responses.ContainerAutoParam{
			Skills: []responses.ContainerAutoSkillUnionParam{
				{OfSkillReference: &responses.SkillReferenceParam{SkillID: "<skill_id>"}},
				{OfSkillReference: &responses.SkillReferenceParam{SkillID: "<skill_id>", Version: openai.String("2")}},
			},
		}},
	}}
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Use the skills to add 144 and 377, then compute triangle area with base 9 height 13.")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.responses.ResponseCreateParams;
import java.util.List;
import java.util.Map;

String skillId = "<skill_id>";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input(
            "Use the skills to add 144 and 377, then compute a triangle area with base 9 and height 13.")
        .putAdditionalBodyProperty(
            "tools",
            JsonValue.from(
                List.of(
                    Map.of(
                        "type",
                        "shell",
                        "environment",
                        Map.of(
                            "type",
                            "container_auto",
                            "skills",
                            List.of(
                                Map.of("type", "skill_reference", "skill_id", skillId),
                                Map.of(
                                    "type", "skill_reference",
                                    "skill_id", skillId,
                                    "version", "2")))))))
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  input: "Use the skills to add 144 and 377, then compute a triangle area with base 9 and height 13.",
  tools: [
    {
      type: :shell,
      environment: {
        type: :container_auto,
        skills: [
          {
            type: :skill_reference,
            skill_id: "<skill_id>"
          },
          {
            type: :skill_reference,
            skill_id: "<skill_id>",
            version: "2"
          }
        ]
      }
    }
  ]
)

puts(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56import { randomUUID } from "node:crypto";
import OpenAI from "openai";
import {
  withLocalSkillSandbox,
  executeShellCall,
  readSkillReport,
} from "../../support/local-skill-sandbox.mjs";

// Requires Docker. The application-owned helper prepares a disposable Python
// sandbox with the skill and CSV files; generated commands run only inside it.
const name = "node-skill-" + randomUUID();

await withLocalSkillSandbox(name, async (signal) => {
  const client = new OpenAI();
  /** @type {OpenAI.Responses.ResponseCreateParamsNonStreaming} */
  const params = {
    model: "gpt-6-astra",
    tools: [
      {
        type: "shell",
        environment: {
          type: "local",
          skills: [
            {
              name: "csv-insights",
              description: "Summarize CSV files and produce a markdown report.",
              path: "/workspace/skills/csv-insights",
            },
          ],
        },
      },
    ],
    input:
      "Use the csv-insights skill and run locally to summarize /workspace/reports.csv. Read the skill instructions, write /workspace/report.md, and include the total in your final answer.",
  };
  for (let turn = 0; turn <= 8; turn++) {
    const response = await client.responses.create(params, { signal });
    if (response.status !== "completed")
      throw new Error(`Response ended with status ${response.status}`);
    const results = [];
    for (const item of response.output) {
      if (item.type !== "shell_call") continue;
      if (turn === 8)
        throw new Error("Shell workflow exceeded eight tool turns");
      results.push(await executeShellCall(name, item, signal));
    }
    if (results.length === 0) {
      console.log(response.output_text);
      console.log("Report:\n" + (await readSkillReport(name, signal)));
      return;
    }
    params.previous_response_id = response.id;
    params.input = results;
  }
  throw new Error("Shell workflow exceeded eight turns");
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22response = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "shell",
            "environment": {
                "type": "local",
                "skills": [
                    {
                        "name": "csv-insights",
                        "description": "Summarize CSV files and produce a markdown report.",
                        "path": "<path-to-skill-folder>",
                    }
                ],
            },
        }
    ],
    input="Use the csv-insights skill and run locally to summarize today's CSV reports in this repo.",
)

# Execute returned shell calls locally and submit their shell_call_output to continue.
print(response.output)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55// The surrounding program prepares an isolated sandbox with the skill files.
client := openai.NewClient()
tool := responses.ToolUnionParam{OfShell: &responses.FunctionShellToolParam{
	Environment: responses.FunctionShellToolEnvironmentUnionParam{
		OfLocal: &responses.LocalEnvironmentParam{
			Skills: []responses.LocalSkillParam{{
				Name:        "csv-insights",
				Description: "Summarize CSV files and produce a markdown report.",
				Path:        "/workspace/skills/csv-insights",
			}},
		},
	},
}}
params := responses.ResponseNewParams{
	Model: "gpt-6-astra",
	Tools: []responses.ToolUnionParam{tool},
	Input: responses.ResponseNewParamsInputUnion{OfString: openai.String(
		"Use the csv-insights skill and run locally to summarize /workspace/reports.csv. Read the skill instructions, write /workspace/report.md, and include the total in your final answer.")},
}
for turn := 0; turn <= 8; turn++ {
	response, err := client.Responses.New(ctx, params)
	if err != nil {
		return err
	}
	if response.Status != responses.ResponseStatusCompleted {
		return fmt.Errorf("response ended with status %s", response.Status)
	}
	results := responses.ResponseInputParam{}
	for _, item := range response.Output {
		if item.Type != "shell_call" {
			continue
		}
		if turn == 8 {
			return fmt.Errorf("shell workflow exceeded eight tool turns")
		}
		result, err := executeShellCall(ctx, name, item.AsShellCall())
		if err != nil {
			return err
		}
		results = append(results, result)
	}
	if len(results) == 0 {
		fmt.Println(response.OutputText())
		// Read the artifact without executing generated code outside the container.
		report, err := readReport(ctx, name)
		if err != nil {
			return fmt.Errorf("read generated report: %w", err)
		}
		fmt.Printf("Report:\n%s\n", report)
		return nil
	}
	params.PreviousResponseID = openai.String(response.ID)
	params.Input = responses.ResponseNewParamsInputUnion{OfInputItemList: results}
}
return fmt.Errorf("shell workflow exceeded eight turns")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.responses.ResponseCreateParams;
import java.util.List;
import java.util.Map;

String skillPath = "<path-to-skill-folder>";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Use the csv-insights skill to summarize today's CSV reports.")
        .putAdditionalBodyProperty(
            "tools",
            JsonValue.from(
                List.of(
                    Map.of(
                        "type",
                        "shell",
                        "environment",
                        Map.of(
                            "type",
                            "local",
                            "skills",
                            List.of(
                                Map.of(
                                    "name", "csv-insights",
                                    "description",
                                        "Summarize CSV files and produce a Markdown report.",
                                    "path", skillPath)))))))
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52require "openai"
require "open3"
require "securerandom"

# LocalSkillSandbox is the application-owned Docker executor defined in this
# complete example. It prepares the skill files, bounds execution, and cleans up.
def run_local_skill(name)
  sandbox = LocalSkillSandbox.new(name)
  begin
    # Reserve teardown before creation, even if Docker creation is interrupted.
    sandbox.prepare
    client = OpenAI::Client.new(max_retries: 0)
    params = {
      model: "gpt-6-astra",
      input: "Use the csv-insights skill and run locally to summarize /workspace/reports.csv. Read the skill instructions, write /workspace/report.md, and include the total in your final answer.",
      tools: [
        {
          type: :shell,
          environment: {
            type: :local,
            skills: [
              {
                name: "csv-insights",
                description: "Summarize CSV files and produce a Markdown report.",
                path: "/workspace/skills/csv-insights"
              }
            ]
          }
        }
      ]
    }
    9.times do |turn|
      response = client.responses.create(**params, request_options: { timeout: sandbox.remaining })
      raise "Response did not complete" unless response.status == OpenAI::Responses::ResponseStatus::COMPLETED

      calls = response.output.grep(OpenAI::Models::Responses::ResponseFunctionShellToolCall)
      if calls.empty?
        puts(response.output_text)
        puts("Report:\n#{sandbox.report}")
        return response
      end
      raise "Shell workflow exceeded eight tool turns" if turn == 8

      params[:input] = calls.map { |call| sandbox.execute(call) }
      params[:previous_response_id] = response.id
    end
  ensure
    sandbox.close
  end
end

run_local_skill("ruby-skill-#{SecureRandom.hex(8)}")